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

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

@@ -0,0 +1,28 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * The value of the Grpc-Status header or trailer in case of success.
+ * Used by the gRPC and gRPC-web protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const grpcStatusOk = "0";
+/**
+ * Sets the fields "grpc-status" and "grpc-message" in the given
+ * Headers object.
+ * If an error is given and contains error details, the function
+ * will also set the field "grpc-status-details-bin" with an encoded
+ * google.rpc.Status message including the error details.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function setTrailerStatus(target: Headers, error: ConnectError | undefined): Headers;
+/**
+ * Find an error status in the given Headers object, which can be either
+ * a trailer, or a header (as allowed for so-called trailers-only responses).
+ * The field "grpc-status-details-bin" is inspected, and if not present,
+ * the fields "grpc-status" and "grpc-message" are used.
+ * Returns an error only if the gRPC status code is > 0.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function findTrailerError(headerOrTrailer: Headers): ConnectError | undefined;

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

@@ -0,0 +1,104 @@
+"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.grpcStatusOk = void 0;
+exports.setTrailerStatus = setTrailerStatus;
+exports.findTrailerError = findTrailerError;
+const protobuf_1 = require("@bufbuild/protobuf");
+const status_pb_js_1 = require("./gen/status_pb.js");
+const connect_error_js_1 = require("../connect-error.js");
+const http_headers_js_1 = require("../http-headers.js");
+const code_js_1 = require("../code.js");
+const headers_js_1 = require("./headers.js");
+/**
+ * The value of the Grpc-Status header or trailer in case of success.
+ * Used by the gRPC and gRPC-web protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.grpcStatusOk = "0";
+/**
+ * Sets the fields "grpc-status" and "grpc-message" in the given
+ * Headers object.
+ * If an error is given and contains error details, the function
+ * will also set the field "grpc-status-details-bin" with an encoded
+ * google.rpc.Status message including the error details.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function setTrailerStatus(target, error) {
+    if (error) {
+        target.set(headers_js_1.headerGrpcStatus, error.code.toString(10));
+        target.set(headers_js_1.headerGrpcMessage, encodeURIComponent(error.rawMessage));
+        if (error.details.length > 0) {
+            const status = new status_pb_js_1.Status({
+                code: error.code,
+                message: error.rawMessage,
+                details: error.details.map((value) => "getType" in value
+                    ? protobuf_1.Any.pack(value)
+                    : new protobuf_1.Any({
+                        typeUrl: `type.googleapis.com/${value.type}`,
+                        value: value.value,
+                    })),
+            });
+            target.set(headers_js_1.headerStatusDetailsBin, (0, http_headers_js_1.encodeBinaryHeader)(status));
+        }
+    }
+    else {
+        target.set(headers_js_1.headerGrpcStatus, exports.grpcStatusOk.toString());
+    }
+    return target;
+}
+/**
+ * Find an error status in the given Headers object, which can be either
+ * a trailer, or a header (as allowed for so-called trailers-only responses).
+ * The field "grpc-status-details-bin" is inspected, and if not present,
+ * the fields "grpc-status" and "grpc-message" are used.
+ * Returns an error only if the gRPC status code is > 0.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function findTrailerError(headerOrTrailer) {
+    // TODO
+    // let code: Code;
+    // let message: string = "";
+    var _a;
+    // Prefer the protobuf-encoded data to the grpc-status header.
+    const statusBytes = headerOrTrailer.get(headers_js_1.headerStatusDetailsBin);
+    if (statusBytes != null) {
+        const status = (0, http_headers_js_1.decodeBinaryHeader)(statusBytes, status_pb_js_1.Status);
+        if (status.code == 0) {
+            return undefined;
+        }
+        const error = new connect_error_js_1.ConnectError(status.message, status.code, headerOrTrailer);
+        error.details = status.details.map((any) => ({
+            type: any.typeUrl.substring(any.typeUrl.lastIndexOf("/") + 1),
+            value: any.value,
+        }));
+        return error;
+    }
+    const grpcStatus = headerOrTrailer.get(headers_js_1.headerGrpcStatus);
+    if (grpcStatus != null) {
+        if (grpcStatus === exports.grpcStatusOk) {
+            return undefined;
+        }
+        const code = parseInt(grpcStatus, 10);
+        if (code in code_js_1.Code) {
+            return new connect_error_js_1.ConnectError(decodeURIComponent((_a = headerOrTrailer.get(headers_js_1.headerGrpcMessage)) !== null && _a !== void 0 ? _a : ""), code, headerOrTrailer);
+        }
+        return new connect_error_js_1.ConnectError(`invalid grpc-status: ${grpcStatus}`, code_js_1.Code.Internal, headerOrTrailer);
+    }
+    return undefined;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc/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 gRPC protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;

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

@@ -0,0 +1,185 @@
+"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 __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+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 request_header_js_1 = require("./request-header.js");
+const validate_response_js_1 = require("./validate-response.js");
+const validate_trailer_js_1 = require("./validate-trailer.js");
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.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");
+const headers_js_1 = require("./headers.js");
+/**
+ * Create a Transport for the gRPC 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)(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : (0, context_values_js_1.createContextValues)(),
+                    message,
+                },
+                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)((0, async_iterable_js_1.createAsyncIterable)([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, headerError } = (0, validate_response_js_1.validateResponseWithCompression)(opt.acceptCompression, uRes.status, uRes.header);
+                    const message = await (0, async_iterable_js_1.pipeTo)(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)), async (iterable) => {
+                        var _a, e_1, _b, _c;
+                        let message;
+                        try {
+                            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = await iterable_1.next(), _a = iterable_1_1.done, !_a; _d = true) {
+                                _c = iterable_1_1.value;
+                                _d = false;
+                                const chunk = _c;
+                                if (message !== undefined) {
+                                    throw new connect_error_js_1.ConnectError("protocol error: received extra output message for unary method", code_js_1.Code.Unimplemented);
+                                }
+                                message = chunk;
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = iterable_1.return)) await _b.call(iterable_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return message;
+                    }, { propagateDownStreamError: false });
+                    (0, validate_trailer_js_1.validateTrailer)(uRes.trailer, uRes.header);
+                    if (message === undefined) {
+                        // Trailers only response
+                        if (headerError) {
+                            throw headerError;
+                        }
+                        throw new connect_error_js_1.ConnectError("protocol error: missing output message for unary method", uRes.trailer.has(headers_js_1.headerGrpcStatus)
+                            ? code_js_1.Code.Unimplemented
+                            : code_js_1.Code.Unknown);
+                    }
+                    if (headerError) {
+                        throw new connect_error_js_1.ConnectError("protocol error: received output message for unary method with error status", code_js_1.Code.Unknown);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header: uRes.header,
+                        message,
+                        trailer: uRes.trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = (0, serialization_js_1.createMethodSerializationLookup)(method, opt.binaryOptions, opt.jsonOptions, opt);
+            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: {},
+                    header: (0, request_header_js_1.requestHeaderWithCompression)(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression),
+                    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, foundStatus, headerError } = (0, validate_response_js_1.validateResponseWithCompression)(opt.acceptCompression, uRes.status, uRes.header);
+                    if (headerError) {
+                        throw headerError;
+                    }
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: uRes.trailer, 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)), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                yield __await(yield* __asyncDelegator(__asyncValues(iterable)));
+                                if (!foundStatus) {
+                                    (0, validate_trailer_js_1.validateTrailer)(uRes.trailer, uRes.header);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the gRPC protocol.
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(status: number, headers: Headers): {
+    foundStatus: boolean;
+    headerError: ConnectError | undefined;
+};
+/**
+ * Validates response status and header for the gRPC protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponseWithCompression(acceptCompression: Compression[], status: number, headers: Headers): {
+    foundStatus: boolean;
+    compression: Compression | undefined;
+    headerError: ConnectError | undefined;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc/validate-response.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.validateResponse = validateResponse;
+exports.validateResponseWithCompression = validateResponseWithCompression;
+const http_status_js_1 = require("./http-status.js");
+const connect_error_js_1 = require("../connect-error.js");
+const trailer_status_js_1 = require("./trailer-status.js");
+const code_js_1 = require("../code.js");
+const headers_js_1 = require("./headers.js");
+const content_type_js_1 = require("./content-type.js");
+/**
+ * Validates response status and header for the gRPC protocol.
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateResponse(status, headers) {
+    if (status != 200) {
+        throw new connect_error_js_1.ConnectError(`HTTP ${status}`, (0, http_status_js_1.codeFromHttpStatus)(status), headers);
+    }
+    const mimeType = headers.get(headers_js_1.headerContentType);
+    const parsedType = (0, content_type_js_1.parseContentType)(mimeType);
+    if (parsedType == undefined) {
+        throw new connect_error_js_1.ConnectError(`unsupported content type ${mimeType}`, code_js_1.Code.Unknown);
+    }
+    return {
+        foundStatus: headers.has(headers_js_1.headerGrpcStatus),
+        headerError: (0, trailer_status_js_1.findTrailerError)(headers),
+    };
+}
+/**
+ * Validates response status and header for the gRPC protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateResponseWithCompression(acceptCompression, status, headers) {
+    const { foundStatus, headerError } = validateResponse(status, headers);
+    let compression;
+    const encoding = headers.get(headers_js_1.headerEncoding);
+    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 {
+        foundStatus,
+        compression,
+        headerError,
+    };
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Validates a trailer for the gRPC and the gRPC-web protocol.
+ *
+ * If the trailer contains an error status, a ConnectError is
+ * thrown. It will include trailer and header in the error's
+ * "metadata" property.
+ *
+ * Throws a ConnectError with code "internal" if neither the trailer
+ * nor the header contain the Grpc-Status field.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateTrailer(trailer: Headers, header: Headers): void;

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

@@ -0,0 +1,44 @@
+"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.validateTrailer = validateTrailer;
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const headers_js_1 = require("./headers.js");
+const trailer_status_js_1 = require("./trailer-status.js");
+/**
+ * Validates a trailer for the gRPC and the gRPC-web protocol.
+ *
+ * If the trailer contains an error status, a ConnectError is
+ * thrown. It will include trailer and header in the error's
+ * "metadata" property.
+ *
+ * Throws a ConnectError with code "internal" if neither the trailer
+ * nor the header contain the Grpc-Status field.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateTrailer(trailer, header) {
+    const err = (0, trailer_status_js_1.findTrailerError)(trailer);
+    if (err) {
+        header.forEach((value, key) => {
+            err.metadata.append(key, value);
+        });
+        throw err;
+    }
+    if (!header.has(headers_js_1.headerGrpcStatus) && !trailer.has(headers_js_1.headerGrpcStatus)) {
+        throw new connect_error_js_1.ConnectError("protocol error: missing status", code_js_1.Code.Internal);
+    }
+}

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

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

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

@@ -0,0 +1,41 @@
+"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-web Content-Type header value.
+ * Note that this includes application/grpc-web-text with the additional base64
+ * encoding.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.contentTypeRegExp = /^application\/grpc-web(-text)?(?:\+(?:(json)(?:; ?charset=utf-?8)?|proto))?$/i;
+exports.contentTypeProto = "application/grpc-web+proto";
+exports.contentTypeJson = "application/grpc-web+json";
+/**
+ * Parse a gRPC-web Content-Type header value.
+ *
+ * @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 text = !!match[1];
+    const binary = !match[2];
+    return { text, binary };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/handler-factory.d.ts

@@ -0,0 +1,6 @@
+import type { ProtocolHandlerFactory } from "../protocol/protocol-handler-factory.js";
+import type { UniversalHandlerOptions } from "../protocol/universal-handler.js";
+/**
+ * Create a factory that creates gRPC-web handlers.
+ */
+export declare function createHandlerFactory(options: Partial<UniversalHandlerOptions>): ProtocolHandlerFactory;