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

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/compression.d.ts

@@ -0,0 +1,48 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const compressedFlag = 1;
+/**
+ * Compression provides methods to compress and decompress data with
+ * a certain compression algorithm.
+ */
+export interface Compression {
+    /**
+     * The name of the compression algorithm.
+     */
+    name: string;
+    /**
+     * Compress a chunk of data.
+     */
+    compress: (bytes: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Decompress a chunk of data.
+     *
+     * A zero-length chunk is acceptable, and will return a zero-length result.
+     *
+     * Raises a ConnectError with Code.InvalidArgument if the decompressed
+     * size exceeds readMaxBytes.
+     */
+    decompress: (bytes: Uint8Array, readMaxBytes: number) => Promise<Uint8Array>;
+}
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function compressionNegotiate(available: Compression[], requested: string | null, // e.g. the value of the Grpc-Encoding header
+accepted: string | null, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding: string): {
+    request: Compression | null;
+    response: Compression | null;
+    error?: ConnectError;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/compression.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressedFlag = void 0;
+exports.compressionNegotiate = compressionNegotiate;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.compressedFlag = 0b00000001;
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function compressionNegotiate(available, requested, // e.g. the value of the Grpc-Encoding header
+accepted, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding) {
+    let request = null;
+    let response = null;
+    let error = undefined;
+    if (requested !== null && requested !== "identity") {
+        const found = available.find((c) => c.name === requested);
+        if (found) {
+            request = found;
+        }
+        else {
+            // To comply with https://github.com/grpc/grpc/blob/master/doc/compression.md
+            // and the Connect protocol, we return code "unimplemented" and specify
+            // acceptable compression(s).
+            const acceptable = available.map((c) => c.name).join(",");
+            error = new connect_error_js_1.ConnectError(`unknown compression "${requested}": supported encodings are ${acceptable}`, code_js_1.Code.Unimplemented, {
+                [headerNameAcceptEncoding]: acceptable,
+            });
+        }
+    }
+    if (accepted === null || accepted === "") {
+        // Support asymmetric compression. This logic follows
+        // https://github.com/grpc/grpc/blob/master/doc/compression.md and common
+        // sense.
+        response = request;
+    }
+    else {
+        const acceptNames = accepted.split(",").map((n) => n.trim());
+        for (const name of acceptNames) {
+            const found = available.find((c) => c.name === name);
+            if (found) {
+                response = found;
+                break;
+            }
+        }
+    }
+    return { request, response, error };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/content-type-matcher.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A function that returns true if a given mime type is supported.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface ContentTypeMatcher {
+    (contentType: string | null): boolean;
+    supported: RegExp[];
+}
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function contentTypeMatcher(...supported: (RegExp | Pick<ContentTypeMatcher, "supported">)[]): ContentTypeMatcher;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/content-type-matcher.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentTypeMatcher = contentTypeMatcher;
+const contentTypeMatcherCacheSize = 1024;
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function contentTypeMatcher(...supported) {
+    const cache = new Map();
+    const source = supported.reduce((previousValue, currentValue) => previousValue.concat("supported" in currentValue ? currentValue.supported : currentValue), []);
+    function match(contentType) {
+        if (contentType === null || contentType.length == 0) {
+            return false;
+        }
+        const cached = cache.get(contentType);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const ok = source.some((re) => re.test(contentType));
+        if (cache.size < contentTypeMatcherCacheSize) {
+            cache.set(contentType, ok);
+        }
+        return ok;
+    }
+    match.supported = source;
+    return match;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/create-method-url.d.ts

@@ -0,0 +1,17 @@
+import type { MethodInfo, ServiceType } from "@bufbuild/protobuf";
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+export declare function createMethodUrl(baseUrl: string | URL, service: ServiceType | string, method: MethodInfo | string): string;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/create-method-url.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMethodUrl = createMethodUrl;
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+function createMethodUrl(baseUrl, service, method) {
+    const s = typeof service == "string" ? service : service.typeName;
+    const m = typeof method == "string" ? method : method.name;
+    return baseUrl.toString().replace(/\/?$/, `/${s}/${m}`);
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/envelope.d.ts

@@ -0,0 +1,59 @@
+import type { Compression } from "./compression.js";
+/**
+ * Represents an Enveloped-Message of the Connect protocol.
+ * https://connectrpc.com/docs/protocol#streaming-rpcs
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface EnvelopedMessage {
+    /**
+     * Envelope-Flags, a set of 8 bitwise flags.
+     */
+    flags: number;
+    /**
+     * Raw data of the message that was enveloped.
+     */
+    data: Uint8Array;
+}
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEnvelopeReadableStream(stream: ReadableStream<Uint8Array>): ReadableStream<EnvelopedMessage>;
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeCompress(envelope: EnvelopedMessage, compression: Compression | null, compressMinBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeDecompress(envelope: EnvelopedMessage, compression: Compression | null, readMaxBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelope(flags: number, data: Uint8Array): Uint8Array;
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelopes(...envelopes: EnvelopedMessage[]): Uint8Array;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/envelope.js

@@ -0,0 +1,152 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnvelopeReadableStream = createEnvelopeReadableStream;
+exports.envelopeCompress = envelopeCompress;
+exports.envelopeDecompress = envelopeDecompress;
+exports.encodeEnvelope = encodeEnvelope;
+exports.encodeEnvelopes = encodeEnvelopes;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const compression_js_1 = require("./compression.js");
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createEnvelopeReadableStream(stream) {
+    let reader;
+    let buffer = new Uint8Array(0);
+    function append(chunk) {
+        const n = new Uint8Array(buffer.length + chunk.length);
+        n.set(buffer);
+        n.set(chunk, buffer.length);
+        buffer = n;
+    }
+    return new ReadableStream({
+        start() {
+            reader = stream.getReader();
+        },
+        async pull(controller) {
+            let header = undefined;
+            for (;;) {
+                if (header === undefined && buffer.byteLength >= 5) {
+                    let length = 0;
+                    for (let i = 1; i < 5; i++) {
+                        length = (length << 8) + buffer[i];
+                    }
+                    header = { flags: buffer[0], length };
+                }
+                if (header !== undefined && buffer.byteLength >= header.length + 5) {
+                    break;
+                }
+                const result = await reader.read();
+                if (result.done) {
+                    break;
+                }
+                append(result.value);
+            }
+            if (header === undefined) {
+                if (buffer.byteLength == 0) {
+                    controller.close();
+                    return;
+                }
+                controller.error(new connect_error_js_1.ConnectError("premature end of stream", code_js_1.Code.DataLoss));
+                return;
+            }
+            const data = buffer.subarray(5, 5 + header.length);
+            buffer = buffer.subarray(5 + header.length);
+            controller.enqueue({
+                flags: header.flags,
+                data,
+            });
+        },
+    });
+}
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function envelopeCompress(envelope, compression, compressMinBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compression_js_1.compressedFlag) === compression_js_1.compressedFlag) {
+        throw new connect_error_js_1.ConnectError("invalid envelope, already compressed", code_js_1.Code.Internal);
+    }
+    if (compression && data.byteLength >= compressMinBytes) {
+        data = await compression.compress(data);
+        flags = flags | compression_js_1.compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function envelopeDecompress(envelope, compression, readMaxBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compression_js_1.compressedFlag) === compression_js_1.compressedFlag) {
+        if (!compression) {
+            throw new connect_error_js_1.ConnectError("received compressed envelope, but do not know how to decompress", code_js_1.Code.Internal);
+        }
+        data = await compression.decompress(data, readMaxBytes);
+        flags = flags ^ compression_js_1.compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function encodeEnvelope(flags, data) {
+    const bytes = new Uint8Array(data.length + 5);
+    bytes.set(data, 5);
+    const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    v.setUint8(0, flags); // first byte is flags
+    v.setUint32(1, data.length); // 4 bytes message length
+    return bytes;
+}
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function encodeEnvelopes(...envelopes) {
+    const len = envelopes.reduce((previousValue, currentValue) => previousValue + currentValue.data.length + 5, 0);
+    const bytes = new Uint8Array(len);
+    const v = new DataView(bytes.buffer);
+    let offset = 0;
+    for (const e of envelopes) {
+        v.setUint8(offset, e.flags); // first byte is flags
+        v.setUint32(offset + 1, e.data.length); // 4 bytes message length
+        bytes.set(e.data, offset + 5);
+        offset += e.data.length + 5;
+    }
+    return bytes;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/index.d.ts

@@ -0,0 +1,24 @@
+export { createMethodUrl } from "./create-method-url.js";
+export type { UniversalClientFn, UniversalClientRequest, UniversalClientResponse, UniversalHandlerFn, UniversalServerRequest, UniversalServerResponse, } from "./universal.js";
+export type { Compression } from "./compression.js";
+export type { UniversalHandler } from "./universal-handler.js";
+export { createUniversalHandlerClient } from "./universal-handler-client.js";
+export { createFetchClient, createFetchHandler, universalClientRequestToFetch, universalClientResponseFromFetch, universalServerRequestFromFetch, universalServerResponseToFetch, } from "./universal-fetch.js";
+export { runUnaryCall, runStreamingCall } from "./run-call.js";
+export { createMethodSerializationLookup, createClientMethodSerializers, getJsonOptions, limitSerialization, } from "./serialization.js";
+export type { Serialization, MethodSerializationLookup, } from "./serialization.js";
+export { validateReadWriteMaxBytes } from "./limit-io.js";
+export { encodeEnvelope, encodeEnvelopes, envelopeDecompress, envelopeCompress, createEnvelopeReadableStream, } from "./envelope.js";
+export type { EnvelopedMessage } from "./envelope.js";
+export { compressedFlag, compressionNegotiate } from "./compression.js";
+export { pipe, transformCatch, transformCatchFinally, transformAppend, transformPrepend, transformReadAllBytes, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformSplitEnvelope, transformSerializeEnvelope, transformParseEnvelope, pipeTo, sinkAll, sinkAllBytes, makeIterableAbortable, createWritableIterable, createAsyncIterable, readAllBytes, untilFirst, } from "./async-iterable.js";
+export type { AsyncIterableTransform, AsyncIterableSink, WritableIterable, } from "./async-iterable.js";
+export { contentTypeMatcher } from "./content-type-matcher.js";
+export type { ContentTypeMatcher } from "./content-type-matcher.js";
+export { invokeUnaryImplementation, transformInvokeImplementation, } from "./invoke-implementation.js";
+export { createLinkedAbortController, getAbortSignalReason, createDeadlineSignal, } from "./signals.js";
+export { assertByteStreamRequest, uResponseOk, uResponseNotFound, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseVersionNotSupported, } from "./universal.js";
+export { validateUniversalHandlerOptions, createUniversalServiceHandlers, createUniversalMethodHandler, } from "./universal-handler.js";
+export type { UniversalHandlerOptions } from "./universal-handler.js";
+export type { ProtocolHandlerFactory } from "./protocol-handler-factory.js";
+export type { CommonTransportOptions } from "./transport-options.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/index.js

@@ -0,0 +1,93 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uResponseOk = exports.assertByteStreamRequest = exports.createDeadlineSignal = exports.getAbortSignalReason = exports.createLinkedAbortController = exports.transformInvokeImplementation = exports.invokeUnaryImplementation = exports.contentTypeMatcher = exports.untilFirst = exports.readAllBytes = exports.createAsyncIterable = exports.createWritableIterable = exports.makeIterableAbortable = exports.sinkAllBytes = exports.sinkAll = exports.pipeTo = exports.transformParseEnvelope = exports.transformSerializeEnvelope = exports.transformSplitEnvelope = exports.transformJoinEnvelopes = exports.transformDecompressEnvelope = exports.transformCompressEnvelope = exports.transformReadAllBytes = exports.transformPrepend = exports.transformAppend = exports.transformCatchFinally = exports.transformCatch = exports.pipe = exports.compressionNegotiate = exports.compressedFlag = exports.createEnvelopeReadableStream = exports.envelopeCompress = exports.envelopeDecompress = exports.encodeEnvelopes = exports.encodeEnvelope = exports.validateReadWriteMaxBytes = exports.limitSerialization = exports.getJsonOptions = exports.createClientMethodSerializers = exports.createMethodSerializationLookup = exports.runStreamingCall = exports.runUnaryCall = exports.universalServerResponseToFetch = exports.universalServerRequestFromFetch = exports.universalClientResponseFromFetch = exports.universalClientRequestToFetch = exports.createFetchHandler = exports.createFetchClient = exports.createUniversalHandlerClient = exports.createMethodUrl = void 0;
+exports.createUniversalMethodHandler = exports.createUniversalServiceHandlers = exports.validateUniversalHandlerOptions = exports.uResponseVersionNotSupported = exports.uResponseMethodNotAllowed = exports.uResponseUnsupportedMediaType = exports.uResponseNotFound = void 0;
+var create_method_url_js_1 = require("./create-method-url.js");
+Object.defineProperty(exports, "createMethodUrl", { enumerable: true, get: function () { return create_method_url_js_1.createMethodUrl; } });
+var universal_handler_client_js_1 = require("./universal-handler-client.js");
+Object.defineProperty(exports, "createUniversalHandlerClient", { enumerable: true, get: function () { return universal_handler_client_js_1.createUniversalHandlerClient; } });
+var universal_fetch_js_1 = require("./universal-fetch.js");
+Object.defineProperty(exports, "createFetchClient", { enumerable: true, get: function () { return universal_fetch_js_1.createFetchClient; } });
+Object.defineProperty(exports, "createFetchHandler", { enumerable: true, get: function () { return universal_fetch_js_1.createFetchHandler; } });
+Object.defineProperty(exports, "universalClientRequestToFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalClientRequestToFetch; } });
+Object.defineProperty(exports, "universalClientResponseFromFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalClientResponseFromFetch; } });
+Object.defineProperty(exports, "universalServerRequestFromFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalServerRequestFromFetch; } });
+Object.defineProperty(exports, "universalServerResponseToFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalServerResponseToFetch; } });
+var run_call_js_1 = require("./run-call.js");
+Object.defineProperty(exports, "runUnaryCall", { enumerable: true, get: function () { return run_call_js_1.runUnaryCall; } });
+Object.defineProperty(exports, "runStreamingCall", { enumerable: true, get: function () { return run_call_js_1.runStreamingCall; } });
+// All exports below are private — internal code that does not follow semantic
+// versioning.
+// We will try hard to avoid breaking changes, but if you depend on the
+// following exports, we recommend that you do so with an exact version
+// constraint (no ~ or ^).
+var serialization_js_1 = require("./serialization.js");
+Object.defineProperty(exports, "createMethodSerializationLookup", { enumerable: true, get: function () { return serialization_js_1.createMethodSerializationLookup; } });
+Object.defineProperty(exports, "createClientMethodSerializers", { enumerable: true, get: function () { return serialization_js_1.createClientMethodSerializers; } });
+Object.defineProperty(exports, "getJsonOptions", { enumerable: true, get: function () { return serialization_js_1.getJsonOptions; } });
+Object.defineProperty(exports, "limitSerialization", { enumerable: true, get: function () { return serialization_js_1.limitSerialization; } });
+var limit_io_js_1 = require("./limit-io.js");
+Object.defineProperty(exports, "validateReadWriteMaxBytes", { enumerable: true, get: function () { return limit_io_js_1.validateReadWriteMaxBytes; } });
+var envelope_js_1 = require("./envelope.js");
+Object.defineProperty(exports, "encodeEnvelope", { enumerable: true, get: function () { return envelope_js_1.encodeEnvelope; } });
+Object.defineProperty(exports, "encodeEnvelopes", { enumerable: true, get: function () { return envelope_js_1.encodeEnvelopes; } });
+Object.defineProperty(exports, "envelopeDecompress", { enumerable: true, get: function () { return envelope_js_1.envelopeDecompress; } });
+Object.defineProperty(exports, "envelopeCompress", { enumerable: true, get: function () { return envelope_js_1.envelopeCompress; } });
+Object.defineProperty(exports, "createEnvelopeReadableStream", { enumerable: true, get: function () { return envelope_js_1.createEnvelopeReadableStream; } });
+var compression_js_1 = require("./compression.js");
+Object.defineProperty(exports, "compressedFlag", { enumerable: true, get: function () { return compression_js_1.compressedFlag; } });
+Object.defineProperty(exports, "compressionNegotiate", { enumerable: true, get: function () { return compression_js_1.compressionNegotiate; } });
+var async_iterable_js_1 = require("./async-iterable.js");
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return async_iterable_js_1.pipe; } });
+Object.defineProperty(exports, "transformCatch", { enumerable: true, get: function () { return async_iterable_js_1.transformCatch; } });
+Object.defineProperty(exports, "transformCatchFinally", { enumerable: true, get: function () { return async_iterable_js_1.transformCatchFinally; } });
+Object.defineProperty(exports, "transformAppend", { enumerable: true, get: function () { return async_iterable_js_1.transformAppend; } });
+Object.defineProperty(exports, "transformPrepend", { enumerable: true, get: function () { return async_iterable_js_1.transformPrepend; } });
+Object.defineProperty(exports, "transformReadAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.transformReadAllBytes; } });
+Object.defineProperty(exports, "transformCompressEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformCompressEnvelope; } });
+Object.defineProperty(exports, "transformDecompressEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformDecompressEnvelope; } });
+Object.defineProperty(exports, "transformJoinEnvelopes", { enumerable: true, get: function () { return async_iterable_js_1.transformJoinEnvelopes; } });
+Object.defineProperty(exports, "transformSplitEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformSplitEnvelope; } });
+Object.defineProperty(exports, "transformSerializeEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformSerializeEnvelope; } });
+Object.defineProperty(exports, "transformParseEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformParseEnvelope; } });
+Object.defineProperty(exports, "pipeTo", { enumerable: true, get: function () { return async_iterable_js_1.pipeTo; } });
+Object.defineProperty(exports, "sinkAll", { enumerable: true, get: function () { return async_iterable_js_1.sinkAll; } });
+Object.defineProperty(exports, "sinkAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.sinkAllBytes; } });
+Object.defineProperty(exports, "makeIterableAbortable", { enumerable: true, get: function () { return async_iterable_js_1.makeIterableAbortable; } });
+Object.defineProperty(exports, "createWritableIterable", { enumerable: true, get: function () { return async_iterable_js_1.createWritableIterable; } });
+Object.defineProperty(exports, "createAsyncIterable", { enumerable: true, get: function () { return async_iterable_js_1.createAsyncIterable; } });
+Object.defineProperty(exports, "readAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.readAllBytes; } });
+Object.defineProperty(exports, "untilFirst", { enumerable: true, get: function () { return async_iterable_js_1.untilFirst; } });
+var content_type_matcher_js_1 = require("./content-type-matcher.js");
+Object.defineProperty(exports, "contentTypeMatcher", { enumerable: true, get: function () { return content_type_matcher_js_1.contentTypeMatcher; } });
+var invoke_implementation_js_1 = require("./invoke-implementation.js");
+Object.defineProperty(exports, "invokeUnaryImplementation", { enumerable: true, get: function () { return invoke_implementation_js_1.invokeUnaryImplementation; } });
+Object.defineProperty(exports, "transformInvokeImplementation", { enumerable: true, get: function () { return invoke_implementation_js_1.transformInvokeImplementation; } });
+var signals_js_1 = require("./signals.js");
+Object.defineProperty(exports, "createLinkedAbortController", { enumerable: true, get: function () { return signals_js_1.createLinkedAbortController; } });
+Object.defineProperty(exports, "getAbortSignalReason", { enumerable: true, get: function () { return signals_js_1.getAbortSignalReason; } });
+Object.defineProperty(exports, "createDeadlineSignal", { enumerable: true, get: function () { return signals_js_1.createDeadlineSignal; } });
+var universal_js_1 = require("./universal.js");
+Object.defineProperty(exports, "assertByteStreamRequest", { enumerable: true, get: function () { return universal_js_1.assertByteStreamRequest; } });
+Object.defineProperty(exports, "uResponseOk", { enumerable: true, get: function () { return universal_js_1.uResponseOk; } });
+Object.defineProperty(exports, "uResponseNotFound", { enumerable: true, get: function () { return universal_js_1.uResponseNotFound; } });
+Object.defineProperty(exports, "uResponseUnsupportedMediaType", { enumerable: true, get: function () { return universal_js_1.uResponseUnsupportedMediaType; } });
+Object.defineProperty(exports, "uResponseMethodNotAllowed", { enumerable: true, get: function () { return universal_js_1.uResponseMethodNotAllowed; } });
+Object.defineProperty(exports, "uResponseVersionNotSupported", { enumerable: true, get: function () { return universal_js_1.uResponseVersionNotSupported; } });
+var universal_handler_js_1 = require("./universal-handler.js");
+Object.defineProperty(exports, "validateUniversalHandlerOptions", { enumerable: true, get: function () { return universal_handler_js_1.validateUniversalHandlerOptions; } });
+Object.defineProperty(exports, "createUniversalServiceHandlers", { enumerable: true, get: function () { return universal_handler_js_1.createUniversalServiceHandlers; } });
+Object.defineProperty(exports, "createUniversalMethodHandler", { enumerable: true, get: function () { return universal_handler_js_1.createUniversalMethodHandler; } });

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol/invoke-implementation.d.ts

@@ -0,0 +1,21 @@
+import { Message, MethodKind } from "@bufbuild/protobuf";
+import type { HandlerContext, MethodImplSpec } from "../implementation.js";
+import type { AsyncIterableTransform } from "./async-iterable.js";
+import type { Interceptor } from "../interceptor.js";
+/**
+ * Invoke a user-provided implementation of a unary RPC. Returns a normalized
+ * output message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function invokeUnaryImplementation<I extends Message<I>, O extends Message<O>>(spec: MethodImplSpec<I, O> & {
+    kind: MethodKind.Unary;
+}, context: HandlerContext, input: I, interceptors: Interceptor[]): Promise<O>;
+/**
+ * Return an AsyncIterableTransform that invokes a user-provided implementation,
+ * giving it input from an asynchronous iterable, and returning its output as an
+ * asynchronous iterable.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function transformInvokeImplementation<I extends Message<I>, O extends Message<O>>(spec: MethodImplSpec<I, O>, context: HandlerContext, interceptors: Interceptor[]): AsyncIterableTransform<I, O>;