pi-cursor-sdk 0.1.4 → 0.1.5

package/node_modules/@connectrpc/connect/dist/cjs/protocol/async-iterable.d.ts

@@ -1,527 +0,0 @@
-import type { EnvelopedMessage } from "./envelope.js";
-import type { Serialization } from "./serialization.js";
-import type { Compression } from "./compression.js";
-/**
- * A function that takes an asynchronous iterable as a source, and returns a
- * transformed asynchronous iterable.
- *
- * The following function is a simple no-op implementation that yields every
- * element from the source:
- *
- * ```ts
- * async function* t<T>(input) {
- *   yield* input;
- * }
- * ```
- *
- * The following function takes fetch responses as a source, and yields the
- * text body of each:
- *
- * ```ts
- * async function* t<T>(input: AsyncIterable<Response>): AsyncIterable<string> {
- *   for await (const r of input) {
- *     yield await r.text();
- *   }
- * }
- * ```
- *
- * Transformation functions can be passed to pipe() and pipeTo().
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export type AsyncIterableTransform<I, O = I> = (data: AsyncIterable<I>) => AsyncIterable<O>;
-/**
- * A function that takes an asynchronous iterable as a source and consumes it
- * to the end, optionally returning a cumulative value.
- *
- * Sinks are the used with pipeTo().
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export type AsyncIterableSink<T, R = void> = (iterable: AsyncIterable<T>) => Promise<R>;
-/**
- * Options for pipe() and pipeTo().
- *
- * @private Internal code, does not follow semantic versioning.
- */
-interface PipeOptions {
-    /**
-     * Set to true to abort the source iterable on downstream errors.
-     * The source iterable must not swallow errors raised by yield.
-     *
-     * Why? If iterators are chained, any error raised by the source or any
-     * transform travels down the stream. But if an error happens downstream, the
-     * source and transformations are left dangling:
-     *
-     * ```ts
-     * async function source*() {
-     *   const conn = await dbConn();
-     *   yield await conn.query("SELECT 1"); // consumed downstream
-     *   yield await conn.query("SELECT 2"); // never consumed
-     *   conn.close(); // never runs
-     * }
-     * for await (const element of source()) {
-     *   // let's say we try to write the element to disk, but the disk is full
-     *   throw "err";
-     * }
-     * ```
-     *
-     * If this option is set to true, an error raised by the sink function given
-     * to pipeTo() will raise the same error in the source iterable.
-     *
-     * ```ts
-     * async function source*() {
-     *   const conn = await dbConn();
-     *   try {
-     *     yield await conn.query("SELECT 1"); // consumed downstream
-     *     yield await conn.query("SELECT 2"); // never consumed
-     *   } finally {
-     *     conn.close(); // runs!
-     *   }
-     * }
-     * await pipeTo(source(), async iterable => {
-     *   for await (const element of source()) {
-     *     // let's say we try to write the element to disk, but the disk is full
-     *     throw "err";
-     *   }
-     * }, { propagateDownStreamError: true });
-     * ```
-     *
-     * If this option is set to true with pipe(), the downstream consumer of the
-     * iterable returned by pipe() can abort the source iterable by calling throw()
-     * on the iterator.
-     */
-    propagateDownStreamError?: boolean;
-}
-/**
- * ParsedEnvelopedMessage is the deserialized counterpart to an
- * EnvelopedMessage.
- *
- * It is either a deserialized message M, or a deserialized end-of-stream
- * message E, typically distinguished by a flag on an enveloped message.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-type ParsedEnvelopedMessage<M, E> = {
-    end: false;
-    value: M;
-} | {
-    end: true;
-    value: E;
-};
-/**
- * Takes an asynchronous iterable as a source, and passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2>(iterable: AsyncIterable<T1>, sink: AsyncIterableSink<T1, T2>, options?: PipeOptions): Promise<T2>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3>(iterable: AsyncIterable<T1>, transform: AsyncIterableTransform<T1, T2>, sink: AsyncIterableSink<T2, T3>, options?: PipeOptions): Promise<T3>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, sink: AsyncIterableSink<T3, T4>, options?: PipeOptions): Promise<T4>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, sink: AsyncIterableSink<T4, T5>, options?: PipeOptions): Promise<T5>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, sink: AsyncIterableSink<T5, T6>, options?: PipeOptions): Promise<T6>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, sink: AsyncIterableSink<T6, T7>, options?: PipeOptions): Promise<T7>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7, T8>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, sink: AsyncIterableSink<T7, T8>, options?: PipeOptions): Promise<T8>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7, T8, T9>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, sink: AsyncIterableSink<T8, T9>, options?: PipeOptions): Promise<T9>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, sink: AsyncIterableSink<T9, T10>, options?: PipeOptions): Promise<T10>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, transform9: AsyncIterableTransform<T9, T10>, sink: AsyncIterableSink<T10, T11>, options?: PipeOptions): Promise<T11>;
-/**
- * Takes an asynchronous iterable as a source, applies transformations, and
- * passes it to a sink.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipeTo<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, transform9: AsyncIterableTransform<T9, T10>, transform10: AsyncIterableTransform<T10, T11>, sink: AsyncIterableSink<T11, T12>, options?: PipeOptions): Promise<T12>;
-/**
- * Creates an AsyncIterableSink that concatenates all elements from the input.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function sinkAll<T>(): AsyncIterableSink<T, T[]>;
-/**
- * Creates an AsyncIterableSink that concatenates all chunks from the input into
- * a single Uint8Array.
- *
- * The iterable raises an error if the more than readMaxBytes are read.
- *
- * An optional length hint can be provided to optimize allocation and validation.
- * If more or less bytes are present in the source that the length hint indicates,
- * and error is raised.
- * If the length hint is larger than readMaxBytes, an error is raised.
- * If the length hint is not a positive integer, it is ignored.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function sinkAllBytes(readMaxBytes: number, lengthHint?: number | string | null): AsyncIterableSink<Uint8Array, Uint8Array>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2>(iterable: AsyncIterable<T1>, transform: AsyncIterableTransform<T1, T2>, options?: PipeOptions): AsyncIterable<T2>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, options?: PipeOptions): AsyncIterable<T3>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, options?: PipeOptions): AsyncIterable<T4>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, options?: PipeOptions): AsyncIterable<T5>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, options?: PipeOptions): AsyncIterable<T6>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, options?: PipeOptions): AsyncIterable<T7>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7, T8>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, options?: PipeOptions): AsyncIterable<T8>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, options?: PipeOptions): AsyncIterable<T9>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, transform9: AsyncIterableTransform<T9, T10>, options?: PipeOptions): AsyncIterable<T10>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, transform9: AsyncIterableTransform<T9, T10>, transform10: AsyncIterableTransform<T10, T11>, options?: PipeOptions): AsyncIterable<T11>;
-/**
- * Apply one or more transformations to an asynchronous iterable.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(iterable: AsyncIterable<T1>, transform1: AsyncIterableTransform<T1, T2>, transform2: AsyncIterableTransform<T2, T3>, transform3: AsyncIterableTransform<T3, T4>, transform4: AsyncIterableTransform<T4, T5>, transform5: AsyncIterableTransform<T5, T6>, transform6: AsyncIterableTransform<T6, T7>, transform7: AsyncIterableTransform<T7, T8>, transform8: AsyncIterableTransform<T8, T9>, transform9: AsyncIterableTransform<T9, T10>, transform10: AsyncIterableTransform<T10, T11>, transform11: AsyncIterableTransform<T11, T12>, options?: PipeOptions): AsyncIterable<T12>;
-/**
- * Creates an AsyncIterableTransform that catches any error from the input, and
- * passes it to the given catchError function.
- *
- * The catchError function may return a final value.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformCatch<T>(catchError: TransformCatchErrorFn<T>): AsyncIterableTransform<T>;
-type TransformCatchErrorFn<C> = ((reason: unknown) => void) | ((reason: unknown) => C | undefined) | ((reason: unknown) => Promise<C | undefined>);
-/**
- * Creates an AsyncIterableTransform that catches any error from the input, and
- * passes it to the given function. Unlike transformCatch(), the given function
- * is also called when no error is raised.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformCatchFinally<T>(catchFinally: TransformCatchFinallyFn<T>): AsyncIterableTransform<T>;
-/**
- * The function to always run at the end of an async iterable.
- * If an error was caught, it is passed as the `reason` argument.
- * If the iterable finished successfully, `reason` is undefined.
- */
-type TransformCatchFinallyFn<C> = ((reason: unknown) => void) | ((reason: unknown) => C | undefined) | ((reason: unknown) => Promise<C | undefined>);
-/**
- * Creates an AsyncIterableTransform that appends a value.
- *
- * The element to append is provided by a function. If the function returns
- * undefined, no element is appended.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformAppend<T>(provide: TransformXpendProvide<T>): AsyncIterableTransform<Awaited<T>>;
-/**
- * Creates an AsyncIterableTransform that prepends an element.
- *
- * The element to prepend is provided by a function. If the function returns
- * undefined, no element is appended.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformPrepend<T>(provide: TransformXpendProvide<T>): AsyncIterableTransform<Awaited<T>>;
-type TransformXpendProvide<T> = T extends undefined ? never : (() => T | undefined) | (() => Promise<T | undefined>);
-/**
- * Creates an AsyncIterableTransform that reads all bytes from the input, and
- * concatenates them to a single Uint8Array.
- *
- * The iterable raises an error if the more than readMaxBytes are read.
- *
- * An optional length hint can be provided to optimize allocation and validation.
- * If more or less bytes are present in the source that the length hint indicates,
- * and error is raised.
- * If the length hint is larger than readMaxBytes, an error is raised.
- * If the length hint is not a positive integer, it is ignored.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformReadAllBytes(readMaxBytes: number, lengthHint?: number | string | null): AsyncIterableTransform<Uint8Array>;
-/**
- * Creates an AsyncIterableTransform that takes a specified type as input,
- * and serializes it as an enveloped messages.
- *
- * Note that this function has an override that lets the input stream
- * distinguish between regular messages, and end-of-stream messages, as used
- * by the RPP-web and Connect protocols.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformSerializeEnvelope<T>(serialization: Serialization<T>): AsyncIterableTransform<T, EnvelopedMessage>;
-/**
- * Creates an AsyncIterableTransform that takes a value or special end type, and
- * serializes it as an enveloped message.
- *
- * For example, a source with { end: true, value: ... } is serialized using
- * the given endSerialization, and the resulting enveloped message has the
- * given endStreamFlag.
- *
- * A source with { end: false, value: ... } is serialized using the given
- * serialization, and the resulting enveloped message does not have the given
- * endStreamFlag.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformSerializeEnvelope<T, E>(serialization: Serialization<T>, endStreamFlag: number, endSerialization: Serialization<E>): AsyncIterableTransform<ParsedEnvelopedMessage<T, E>, EnvelopedMessage>;
-/**
- * Creates an AsyncIterableTransform that takes enveloped messages as input,
- * parses the envelope payload and outputs the result.
- *
- * Note that this function has overrides that let the stream distinguish
- * between regular messages, and end-of-stream messages, as used by the
- * gRPP-web and Connect protocols.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformParseEnvelope<T>(serialization: Serialization<T>): AsyncIterableTransform<EnvelopedMessage, T>;
-/**
- * Creates an AsyncIterableTransform that takes enveloped messages as input,
- * parses the envelope payload and outputs the result.
- *
- * Note that this override will look for the given endStreamFlag, and silently
- * ignore envelopes with this flag.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformParseEnvelope<T>(serialization: Serialization<T>, endStreamFlag: number): AsyncIterableTransform<EnvelopedMessage, T>;
-/**
- * Creates an AsyncIterableTransform that takes enveloped messages as input,
- * parses the envelope payload and outputs the result.
- *
- * Note that this override will look for the given endStreamFlag, and raise
- * and error if it is set.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformParseEnvelope<T>(serialization: Serialization<T>, endStreamFlag: number, endSerialization: null): AsyncIterableTransform<EnvelopedMessage, T>;
-/**
- * Creates an AsyncIterableTransform that takes an enveloped message as input,
- * and outputs a ParsedEnvelopedMessage.
- *
- * For example, if the given endStreamFlag is set for a source envelope, its
- * payload is parsed using the given endSerialization, and an object with
- * { end: true, value: ... } is returned.
- *
- * If the endStreamFlag is not set, the payload is parsed using the given
- * serialization, and an object with { end: false, value: ... } is returned.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformParseEnvelope<T, E>(serialization: Serialization<T>, endStreamFlag: number, endSerialization: Serialization<E>): AsyncIterableTransform<EnvelopedMessage, ParsedEnvelopedMessage<T, E>>;
-/**
- * Creates an AsyncIterableTransform that takes enveloped messages as a source,
- * and compresses them if they are larger than compressMinBytes.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformCompressEnvelope(compression: Compression | null, compressMinBytes: number): AsyncIterableTransform<EnvelopedMessage, EnvelopedMessage>;
-/**
- * Creates an AsyncIterableTransform that takes enveloped messages as a source,
- * and decompresses them using the given compression.
- *
- * The iterable raises an error if the decompressed payload of an enveloped
- * message is larger than readMaxBytes, or if no compression is provided.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformDecompressEnvelope(compression: Compression | null, readMaxBytes: number): AsyncIterableTransform<EnvelopedMessage, EnvelopedMessage>;
-/**
- * Create an AsyncIterableTransform that takes enveloped messages as a source,
- * and joins them into a stream of raw bytes.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformJoinEnvelopes(): AsyncIterableTransform<EnvelopedMessage, Uint8Array>;
-/**
- * Create an AsyncIterableTransform that takes raw bytes as a source, and splits
- * them into enveloped messages.
- *
- * The iterable raises an error
- * - if the payload of an enveloped message is larger than readMaxBytes,
- * - if the stream ended before an enveloped message fully arrived,
- * - or if the stream ended with extraneous data.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function transformSplitEnvelope(readMaxBytes: number): AsyncIterableTransform<Uint8Array, EnvelopedMessage>;
-/**
- * Reads all bytes from the source, and concatenates them to a single Uint8Array.
- *
- * Raises an error if:
- * - more than readMaxBytes are read
- * - lengthHint is a positive integer, but larger than readMaxBytes
- * - lengthHint is a positive integer, and the source contains more or less bytes
- *   than promised
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function readAllBytes(iterable: AsyncIterable<Uint8Array>, readMaxBytes: number, lengthHint?: number | string | null): Promise<Uint8Array>;
-/**
- * Wait for the first element of an iterable without modifying the iterable.
- * This consumes the first element, but pushes it back on the stack.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function untilFirst<T>(iterable: AsyncIterable<T>): Promise<AsyncIterable<T>>;
-interface Abortable {
-    /**
-     * Abort the iterator.
-     */
-    readonly abort: (reason: unknown) => Promise<AbortState>;
-}
-type AbortState = "rethrown" | "completed" | "caught";
-/**
- * Wrap the given iterable and return an iterable with an abort() method.
- *
- * This function exists purely for convenience. Where one would typically have
- * to access the iterator directly, advance through all elements, and call
- * AsyncIterator.throw() to notify the upstream iterable, this function allows
- * to use convenient for-await loops and still notify the upstream iterable:
- *
- * ```ts
- * const abortable = makeIterableAbortable(iterable);
- * for await (const ele of abortable) {
- *   await abortable.abort("ERR");
- * }
- * ```
- * There are a couple of limitations of this function:
- * - the given async iterable must implement throw
- * - the async iterable cannot be re-use
- * - if source catches errors and yields values for them, they are ignored, and
- *   the source may still dangle
- *
- * There are four possible ways an async function* can handle yield errors:
- * 1. don't catch errors at all - Abortable.abort() will resolve "rethrown"
- * 2. catch errors and rethrow - Abortable.abort() will resolve "rethrown"
- * 3. catch errors and return - Abortable.abort() will resolve "completed"
- * 4. catch errors and yield a value - Abortable.abort() will resolve "caught"
- *
- * Note that catching errors and yielding a value is problematic, and it should
- * be documented that this may leave the source in a dangling state.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function makeIterableAbortable<T>(iterable: AsyncIterable<T>): AsyncIterable<T> & Abortable;
-/**
- * WritableIterable is an AsyncIterable that can be used
- * to supply values imperatively to the consumer of the
- * AsyncIterable.
- */
-export interface WritableIterable<T> extends AsyncIterable<T> {
-    /**
-     * Makes the payload available to the consumer of the
-     * iterable.
-     */
-    write: (payload: T) => Promise<void>;
-    /**
-     * Closes the writer indicating to its consumer that no further
-     * payloads will be received.
-     *
-     * Any writes that happen after close is called will return an error.
-     */
-    close: () => void;
-}
-/**
- * Create a new WritableIterable.
- */
-export declare function createWritableIterable<T>(): WritableIterable<T>;
-/**
- * Create an asynchronous iterable from an array.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function createAsyncIterable<T>(items: T[]): AsyncIterable<T>;
-export {};