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

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/request-header.js

@@ -0,0 +1,70 @@
+"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.requestHeader = requestHeader;
+exports.requestHeaderWithCompression = requestHeaderWithCompression;
+const protobuf_1 = require("@bufbuild/protobuf");
+const headers_js_1 = require("./headers.js");
+const version_js_1 = require("./version.js");
+const content_type_js_1 = require("./content-type.js");
+/**
+ * Creates headers for a Connect request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    if (timeoutMs !== undefined) {
+        result.set(headers_js_1.headerTimeout, `${timeoutMs}`);
+    }
+    result.set(headers_js_1.headerContentType, methodKind == protobuf_1.MethodKind.Unary
+        ? useBinaryFormat
+            ? content_type_js_1.contentTypeUnaryProto
+            : content_type_js_1.contentTypeUnaryJson
+        : useBinaryFormat
+            ? content_type_js_1.contentTypeStreamProto
+            : content_type_js_1.contentTypeStreamJson);
+    result.set(headers_js_1.headerProtocolVersion, version_js_1.protocolVersion);
+    if (setUserAgent && !result.has(headers_js_1.headerUserAgent)) {
+        result.set(headers_js_1.headerUserAgent, "connect-es/1.7.0");
+    }
+    return result;
+}
+/**
+ * Creates headers for a Connect request with compression.
+ *
+ * Note that we always set the Content-Encoding header for unary methods.
+ * It is up to the caller to decide whether to apply compression - and remove
+ * the header if compression is not used, for example because the payload is
+ * too small to make compression effective.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requestHeaderWithCompression(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
+    const result = requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
+    if (sendCompression != null) {
+        const name = methodKind == protobuf_1.MethodKind.Unary
+            ? headers_js_1.headerUnaryEncoding
+            : headers_js_1.headerStreamEncoding;
+        result.set(name, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        const name = methodKind == protobuf_1.MethodKind.Unary
+            ? headers_js_1.headerUnaryAcceptEncoding
+            : headers_js_1.headerStreamAcceptEncoding;
+        result.set(name, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/trailer-mux.d.ts

@@ -0,0 +1,19 @@
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerDemux(header: Headers): [header: Headers, trailer: Headers];
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerMux(header: Headers, trailer: Headers): Headers;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/trailer-mux.js

@@ -0,0 +1,53 @@
+"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.trailerDemux = trailerDemux;
+exports.trailerMux = trailerMux;
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function trailerDemux(header) {
+    const h = new Headers(), t = new Headers();
+    header.forEach((value, key) => {
+        if (key.toLowerCase().startsWith("trailer-")) {
+            t.append(key.substring(8), value);
+        }
+        else {
+            h.append(key, value);
+        }
+    });
+    return [h, t];
+}
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function trailerMux(header, trailer) {
+    const h = new Headers(header);
+    trailer.forEach((value, key) => {
+        h.append(`trailer-${key}`, value);
+    });
+    return h;
+}

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

@@ -0,0 +1,6 @@
+import type { CommonTransportOptions } from "../protocol/transport-options.js";
+import type { Transport } from "../transport.js";
+/**
+ * Create a Transport for the Connect protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;

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

@@ -0,0 +1,214 @@
+"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.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = createTransport;
+const protobuf_1 = require("@bufbuild/protobuf");
+const request_header_js_1 = require("./request-header.js");
+const headers_js_1 = require("./headers.js");
+const validate_response_js_1 = require("./validate-response.js");
+const trailer_mux_js_1 = require("./trailer-mux.js");
+const error_json_js_1 = require("./error-json.js");
+const end_stream_js_1 = require("./end-stream.js");
+const get_request_js_1 = require("./get-request.js");
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const http_headers_js_1 = require("../http-headers.js");
+const async_iterable_js_1 = require("../protocol/async-iterable.js");
+const create_method_url_js_1 = require("../protocol/create-method-url.js");
+const run_call_js_1 = require("../protocol/run-call.js");
+const serialization_js_1 = require("../protocol/serialization.js");
+const context_values_js_1 = require("../context-values.js");
+/**
+ * Create a Transport for the Connect protocol.
+ */
+function createTransport(opt) {
+    return {
+        async unary(service, method, signal, timeoutMs, header, message, contextValues) {
+            const serialization = (0, serialization_js_1.createMethodSerializationLookup)(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return await (0, run_call_js_1.runUnaryCall)({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: false,
+                    service,
+                    method,
+                    url: (0, create_method_url_js_1.createMethodUrl)(opt.baseUrl, service, method),
+                    init: {},
+                    header: (0, request_header_js_1.requestHeaderWithCompression)(method.kind, opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : (0, context_values_js_1.createContextValues)(),
+                    message,
+                },
+                next: async (req) => {
+                    var _a;
+                    let requestBody = serialization
+                        .getI(opt.useBinaryFormat)
+                        .serialize(req.message);
+                    if (opt.sendCompression &&
+                        requestBody.byteLength > opt.compressMinBytes) {
+                        requestBody = await opt.sendCompression.compress(requestBody);
+                        req.header.set(headers_js_1.headerUnaryEncoding, opt.sendCompression.name);
+                    }
+                    else {
+                        req.header.delete(headers_js_1.headerUnaryEncoding);
+                    }
+                    const useGet = opt.useHttpGet === true &&
+                        method.idempotency === protobuf_1.MethodIdempotency.NoSideEffects;
+                    let body;
+                    if (useGet) {
+                        req = (0, get_request_js_1.transformConnectPostToGetRequest)(req, requestBody, opt.useBinaryFormat);
+                    }
+                    else {
+                        body = (0, async_iterable_js_1.createAsyncIterable)([requestBody]);
+                    }
+                    const universalResponse = await opt.httpClient({
+                        url: req.url,
+                        method: (_a = req.init.method) !== null && _a !== void 0 ? _a : "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body,
+                    });
+                    const { compression, isUnaryError, unaryError } = (0, validate_response_js_1.validateResponseWithCompression)(method.kind, opt.acceptCompression, opt.useBinaryFormat, universalResponse.status, universalResponse.header);
+                    const [header, trailer] = (0, trailer_mux_js_1.trailerDemux)(universalResponse.header);
+                    let responseBody = await (0, async_iterable_js_1.pipeTo)(universalResponse.body, (0, async_iterable_js_1.sinkAllBytes)(opt.readMaxBytes, universalResponse.header.get(headers_js_1.headerUnaryContentLength)), { propagateDownStreamError: false });
+                    if (compression) {
+                        responseBody = await compression.decompress(responseBody, opt.readMaxBytes);
+                    }
+                    if (isUnaryError) {
+                        throw (0, error_json_js_1.errorFromJsonBytes)(responseBody, (0, http_headers_js_1.appendHeaders)(header, trailer), unaryError);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header,
+                        message: serialization
+                            .getO(opt.useBinaryFormat)
+                            .parse(responseBody),
+                        trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = (0, serialization_js_1.createMethodSerializationLookup)(method, opt.binaryOptions, opt.jsonOptions, opt);
+            const endStreamSerialization = (0, end_stream_js_1.createEndStreamSerialization)(opt.jsonOptions);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return (0, run_call_js_1.runStreamingCall)({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: true,
+                    service,
+                    method,
+                    url: (0, create_method_url_js_1.createMethodUrl)(opt.baseUrl, service, method),
+                    init: {
+                        method: "POST",
+                        redirect: "error",
+                        mode: "cors",
+                    },
+                    header: (0, request_header_js_1.requestHeaderWithCompression)(method.kind, opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : (0, context_values_js_1.createContextValues)(),
+                    message: input,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: (0, async_iterable_js_1.pipe)(req.message, (0, async_iterable_js_1.transformSerializeEnvelope)(serialization.getI(opt.useBinaryFormat)), (0, async_iterable_js_1.transformCompressEnvelope)(opt.sendCompression, opt.compressMinBytes), (0, async_iterable_js_1.transformJoinEnvelopes)(), { propagateDownStreamError: true }),
+                    });
+                    const { compression } = (0, validate_response_js_1.validateResponseWithCompression)(method.kind, opt.acceptCompression, opt.useBinaryFormat, uRes.status, uRes.header);
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: new Headers(), message: (0, async_iterable_js_1.pipe)(uRes.body, (0, async_iterable_js_1.transformSplitEnvelope)(opt.readMaxBytes), (0, async_iterable_js_1.transformDecompressEnvelope)(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), (0, async_iterable_js_1.transformParseEnvelope)(serialization.getO(opt.useBinaryFormat), end_stream_js_1.endStreamFlag, endStreamSerialization), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                var _a, e_1, _b, _c;
+                                let endStreamReceived = false;
+                                try {
+                                    for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+                                        _c = iterable_1_1.value;
+                                        _d = false;
+                                        const chunk = _c;
+                                        if (chunk.end) {
+                                            if (endStreamReceived) {
+                                                throw new connect_error_js_1.ConnectError("protocol error: received extra EndStreamResponse", code_js_1.Code.InvalidArgument);
+                                            }
+                                            endStreamReceived = true;
+                                            if (chunk.value.error) {
+                                                const error = chunk.value.error;
+                                                uRes.header.forEach((value, key) => {
+                                                    error.metadata.append(key, value);
+                                                });
+                                                throw error;
+                                            }
+                                            chunk.value.metadata.forEach((value, key) => res.trailer.set(key, value));
+                                            continue;
+                                        }
+                                        if (endStreamReceived) {
+                                            throw new connect_error_js_1.ConnectError("protocol error: received extra message after EndStreamResponse", code_js_1.Code.InvalidArgument);
+                                        }
+                                        yield yield __await(chunk.value);
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                                if (!endStreamReceived) {
+                                    throw new connect_error_js_1.ConnectError("protocol error: missing EndStreamResponse", code_js_1.Code.InvalidArgument);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/validate-response.d.ts

@@ -0,0 +1,30 @@
+import { MethodKind } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(methodKind: MethodKind, useBinaryFormat: boolean, status: number, headers: Headers): {
+    isUnaryError: false;
+    unaryError?: undefined;
+} | {
+    isUnaryError: true;
+    unaryError: ConnectError;
+};
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+export declare function validateResponseWithCompression(methodKind: MethodKind, acceptCompression: Compression[], useBinaryFormat: boolean, status: number, headers: Headers): ReturnType<typeof validateResponse> & {
+    compression: Compression | undefined;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/validate-response.js

@@ -0,0 +1,72 @@
+"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.validateResponse = validateResponse;
+exports.validateResponseWithCompression = validateResponseWithCompression;
+const protobuf_1 = require("@bufbuild/protobuf");
+const code_js_1 = require("../code.js");
+const http_status_js_1 = require("./http-status.js");
+const connect_error_js_1 = require("../connect-error.js");
+const content_type_js_1 = require("./content-type.js");
+const headers_js_1 = require("./headers.js");
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateResponse(methodKind, useBinaryFormat, status, headers) {
+    const mimeType = headers.get(headers_js_1.headerContentType);
+    const parsedType = (0, content_type_js_1.parseContentType)(mimeType);
+    if (status !== 200) {
+        const errorFromStatus = new connect_error_js_1.ConnectError(`HTTP ${status}`, (0, http_status_js_1.codeFromHttpStatus)(status), headers);
+        // If parsedType is defined and it is not binary, then this is a unary JSON response
+        if (methodKind == protobuf_1.MethodKind.Unary && parsedType && !parsedType.binary) {
+            return { isUnaryError: true, unaryError: errorFromStatus };
+        }
+        throw errorFromStatus;
+    }
+    const allowedContentType = {
+        binary: useBinaryFormat,
+        stream: methodKind !== protobuf_1.MethodKind.Unary,
+    };
+    if ((parsedType === null || parsedType === void 0 ? void 0 : parsedType.binary) !== allowedContentType.binary ||
+        parsedType.stream !== allowedContentType.stream) {
+        throw new connect_error_js_1.ConnectError(`unsupported content type ${mimeType}`, parsedType === undefined ? code_js_1.Code.Unknown : code_js_1.Code.Internal, headers);
+    }
+    return { isUnaryError: false };
+}
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+function validateResponseWithCompression(methodKind, acceptCompression, useBinaryFormat, status, headers) {
+    let compression;
+    const encoding = headers.get(methodKind == protobuf_1.MethodKind.Unary ? headers_js_1.headerUnaryEncoding : headers_js_1.headerStreamEncoding);
+    if (encoding != null && encoding.toLowerCase() !== "identity") {
+        compression = acceptCompression.find((c) => c.name === encoding);
+        if (!compression) {
+            throw new connect_error_js_1.ConnectError(`unsupported response encoding "${encoding}"`, code_js_1.Code.Internal, headers);
+        }
+    }
+    return Object.assign({ compression }, validateResponse(methodKind, useBinaryFormat, status, headers));
+}

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

@@ -0,0 +1,20 @@
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionHeader(requestHeader: Headers): void;
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionParam(queryParams: URLSearchParams): void;

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

@@ -0,0 +1,58 @@
+"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.protocolVersion = void 0;
+exports.requireProtocolVersionHeader = requireProtocolVersionHeader;
+exports.requireProtocolVersionParam = requireProtocolVersionParam;
+const headers_js_1 = require("./headers.js");
+const query_params_js_1 = require("./query-params.js");
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requireProtocolVersionHeader(requestHeader) {
+    const v = requestHeader.get(headers_js_1.headerProtocolVersion);
+    if (v === null) {
+        throw new connect_error_js_1.ConnectError(`missing required header: set ${headers_js_1.headerProtocolVersion} to "${exports.protocolVersion}"`, code_js_1.Code.InvalidArgument);
+    }
+    else if (v !== exports.protocolVersion) {
+        throw new connect_error_js_1.ConnectError(`${headers_js_1.headerProtocolVersion} must be "${exports.protocolVersion}": got "${v}"`, code_js_1.Code.InvalidArgument);
+    }
+}
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requireProtocolVersionParam(queryParams) {
+    const v = queryParams.get(query_params_js_1.paramConnectVersion);
+    if (v === null) {
+        throw new connect_error_js_1.ConnectError(`missing required parameter: set ${query_params_js_1.paramConnectVersion} to "v${exports.protocolVersion}"`, code_js_1.Code.InvalidArgument);
+    }
+    else if (v !== `v${exports.protocolVersion}`) {
+        throw new connect_error_js_1.ConnectError(`${query_params_js_1.paramConnectVersion} must be "v${exports.protocolVersion}": got "${v}"`, code_js_1.Code.InvalidArgument);
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeRegExp: RegExp;
+export declare const contentTypeProto = "application/grpc+proto";
+export declare const contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseContentType(contentType: string | null): {
+    binary: boolean;
+} | undefined;

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

@@ -0,0 +1,38 @@
+"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.contentTypeJson = exports.contentTypeProto = exports.contentTypeRegExp = void 0;
+exports.parseContentType = parseContentType;
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.contentTypeRegExp = /^application\/grpc(?:\+(?:(json)(?:; ?charset=utf-?8)?|proto))?$/i;
+exports.contentTypeProto = "application/grpc+proto";
+exports.contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function parseContentType(contentType) {
+    const match = contentType === null || contentType === void 0 ? void 0 : contentType.match(exports.contentTypeRegExp);
+    if (!match) {
+        return undefined;
+    }
+    const binary = !match[1];
+    return { binary };
+}