@in-human-resources/backend-proto 0.1.5 → 0.1.6

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

@@ -0,0 +1,527 @@
+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 {};