import type { L } from 'ts-toolbelt';
import type { RequiredProps } from './Object.js';
import type { UnderlyingDefaultSource, UnderlyingSink } from 'node:stream/web';
/**
 * Something that can be flushed by another stream.
 *
 * @group Utils
 * @category Stream
 */
export interface Flushable {
    flushes?: ReadableStream<unknown>;
    /**
     * By default an error in the `flushes` stream will be sent by the transformer.
     */
    ignoreFlushErrors?: boolean;
}
/**
 * Using a {@link Flushable} notify when the stream
 * flushes and errors.
 *
 * @group Utils
 * @category Stream
 */
export declare function pipeFlushes(onFlush: () => void | Promise<void>, onError: (error: unknown) => unknown, options?: Flushable & {
    signal?: AbortSignal;
}): void;
/**
 * Returns the chunk type of a ReadableStream.
 *
 * @group Utils
 * @category Stream
 * @example
 * ```
 * type T = ReadableStreamChunk<ReadableStream<number>>
 * // number
 * ```
 */
export type ReadableStreamChunk<R extends ReadableStream<unknown>> = R extends ReadableStream<infer T> ? T : never;
/**
 * Returns the union chunk type of a list of ReadableStreams.
 *
 * @group Utils
 * @category Stream
 * @example
 * ```
 * type T = ReadableStreamsChunk<[ReadableStream<number>, ReadableStream<string>]>
 * // number | string
 * ```
 */
export type ReadableStreamsChunk<RSs extends ReadableStream<unknown>[]> = RSs extends ReadableStream<infer T>[] ? T : never;
/**
 * Creates a tuple type of the chunk types from a list of
 * ReadableStreams.
 *
 * @group Utils
 * @category Stream
 * @example
 * ```
 * type T = ReadableStreamsChunks<[
 *   ReadableStream<number>,
 *   ReadableStream<string>,
 *   ReadableStream<string>,
 *   ReadableStream<number>,
 * ]>
 * // [number, string, string, number]
 * ```
 */
export type ReadableStreamsChunks<Rs extends ReadableStream<unknown>[]> = _ReadableStreamsChunks<Rs, []>;
type _ReadableStreamsChunks<Rs extends ReadableStream<unknown>[], Acc extends unknown[]> = L.Length<Rs> extends 0 ? Acc : _ReadableStreamsChunks<L.Tail<Rs>, [
    ...Acc,
    ReadableStreamChunk<L.Head<Rs>>
]>;
/**
 * An underlying source that immediately closes.
 *
 * @group Sources
 */
export declare function immediatelyClosingUnderlyingSource(): UnderlyingDefaultSource<never>;
/**
 * Creates a ReadableStream that immediately closes.
 *
 * @group Sources
 */
export declare function immediatelyClosingReadableStream(): import("node:stream/web").ReadableStream<never>;
export declare function mergeUnderlyingSource<RSs extends ReadableStream<unknown>[]>(readableStreams: RSs | (() => RSs)): UnderlyingDefaultSource<ReadableStreamsChunk<RSs>>;
/**
 * Merges multiple streams in to 1 ReadableStream.
 *
 * Warning: this may create a bottleneck as the highwater mark
 * can easily be breached. This is because every pull will attempt to
 * read and queue at least one chunk from each incoming stream.
 *
 * @group Sources
 * @see {@link roundRobin:function}
 * @example
 * ```
 * merge([
 * --1----2-----3-------4------|
 * ---one---two---three---four-|
 * ])
 *
 * -1-one-2-two-3-three-4-four-|
 * ```
 */
export declare function merge<RSs extends ReadableStream<unknown>[]>(readableStreams: RSs | (() => RSs), queuingStrategy?: QueuingStrategy<ReadableStreamsChunk<RSs>>): import("node:stream/web").ReadableStream<ReadableStreamsChunk<RSs>>;
/**
 * Consume chunks from a ReadableStream. Syntactical sugar
 * for a simple WritableStream.
 *
 * @group Sinks
 * @example
 * ```
 * readableStream.pipeTo(write(console.info))
 *
 * // ... instead of ...
 *
 * readableStream.pipeTo(new WritableStream({
 *   write(chunk) {
 *     console.info(chunk)
 *   }
 * }))
 * ```
 */
export declare function write<T>(fn?: (chunk: T) => unknown, queuingStrategy?: QueuingStrategy<T>): import("node:stream/web").WritableStream<T>;
/**
 * An `UnderlyingDefaultSource` object that has a `cancel` method.
 *
 * @group Utils
 * @category Stream
 */
export type CancellableSource<T> = RequiredProps<UnderlyingDefaultSource<T>, 'cancel'>;
/**
 * A guard to test that an `UnderlyingDefaultSource` object that has a `cancel` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isCancellableSource<T>(source: UnderlyingDefaultSource<T>): source is CancellableSource<T>;
/**
 * An `UnderlyingDefaultSource` object that has a `pull` method.
 *
 * @group Utils
 * @category Stream
 */
export type PullableSource<T> = RequiredProps<UnderlyingDefaultSource<T>, 'pull'>;
/**
 * A guard to test that an `UnderlyingDefaultSource` object that has a `pull` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isPullableSource<T>(source: UnderlyingDefaultSource<T>): source is PullableSource<T>;
/**
 * An `UnderlyingDefaultSource` object that has a `start` method.
 *
 * @group Utils
 * @category Stream
 */
export type StartableSource<T> = RequiredProps<UnderlyingDefaultSource<T>, 'start'>;
/**
 * A guard to test that an `UnderlyingDefaultSource` object that has a `start` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isStartableSource<T>(source: UnderlyingDefaultSource<T>): source is StartableSource<T>;
/**
 * An `UnderlyingSink` object that has an `abort` method.
 *
 * @group Utils
 * @category Stream
 */
export type AbortableSink<T> = RequiredProps<UnderlyingSink<T>, 'abort'>;
/**
 * A guard to test that an `UnderlyingSink` object that has an `abort` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isAbortableSink<T>(sink: UnderlyingSink<T>): sink is AbortableSink<T>;
/**
 * An `UnderlyingSink` object that has a `close` method.
 *
 * @group Utils
 * @category Stream
 */
export type ClosableSink<T> = RequiredProps<UnderlyingSink<T>, 'close'>;
/**
 * A guard to test that an `UnderlyingSink` object that has a `close` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isClosableSink<T>(sink: UnderlyingSink<T>): sink is ClosableSink<T>;
/**
 * An `UnderlyingSink` object that has a `start` method.
 *
 * @group Utils
 * @category Stream
 */
export type StartableSink<T> = RequiredProps<UnderlyingSink<T>, 'start'>;
/**
 * A guard to test that an `UnderlyingSink` object that has a `start` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isStartableSink<T>(sink: UnderlyingSink<T>): sink is StartableSink<T>;
/**
 * An `UnderlyingSink` object that has a `write` method.
 *
 * @group Utils
 * @category Stream
 */
export type WritableSink<T> = RequiredProps<UnderlyingSink<T>, 'write'>;
/**
 * A guard to test that an `UnderlyingSink` object that has a `write` method.
 *
 * @group Utils
 * @category Stream
 */
export declare function isWritableSink<T>(sink: UnderlyingSink<T>): sink is WritableSink<T>;
export {};
//# sourceMappingURL=Stream.d.ts.map