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

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/gen/status_pb.js

@@ -0,0 +1,116 @@
+// 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.
+import { Any, Message, proto3 } from "@bufbuild/protobuf";
+/**
+ * The `Status` type defines a logical error model that is suitable for different
+ * programming environments, including REST APIs and RPC APIs. It is used by
+ * [gRPC](https://github.com/grpc). The error model is designed to be:
+ *
+ * - Simple to use and understand for most users
+ * - Flexible enough to meet unexpected needs
+ *
+ * # Overview
+ *
+ * The `Status` message contains three pieces of data: error code, error message,
+ * and error details. The error code should be an enum value of
+ * [google.rpc.Code][google.rpc.Code], but it may accept additional error codes if needed.  The
+ * error message should be a developer-facing English message that helps
+ * developers *understand* and *resolve* the error. If a localized user-facing
+ * error message is needed, put the localized message in the error details or
+ * localize it in the client. The optional error details may contain arbitrary
+ * information about the error. There is a predefined set of error detail types
+ * in the package `google.rpc` which can be used for common error conditions.
+ *
+ * # Language mapping
+ *
+ * The `Status` message is the logical representation of the error model, but it
+ * is not necessarily the actual wire format. When the `Status` message is
+ * exposed in different client libraries and different wire protocols, it can be
+ * mapped differently. For example, it will likely be mapped to some exceptions
+ * in Java, but more likely mapped to some error codes in C.
+ *
+ * # Other uses
+ *
+ * The error model and the `Status` message can be used in a variety of
+ * environments, either with or without APIs, to provide a
+ * consistent developer experience across different environments.
+ *
+ * Example uses of this error model include:
+ *
+ * - Partial errors. If a service needs to return partial errors to the client,
+ *     it may embed the `Status` in the normal response to indicate the partial
+ *     errors.
+ *
+ * - Workflow errors. A typical workflow has multiple steps. Each step may
+ *     have a `Status` message for error reporting purpose.
+ *
+ * - Batch operations. If a client uses batch request and batch response, the
+ *     `Status` message should be used directly inside batch response, one for
+ *     each error sub-response.
+ *
+ * - Asynchronous operations. If an API call embeds asynchronous operation
+ *     results in its response, the status of those operations should be
+ *     represented directly using the `Status` message.
+ *
+ * - Logging. If some API errors are stored in logs, the message `Status` could
+ *     be used directly after any stripping needed for security/privacy reasons.
+ *
+ * @generated from message google.rpc.Status
+ */
+export class Status extends Message {
+    constructor(data) {
+        super();
+        /**
+         * The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+         *
+         * @generated from field: int32 code = 1;
+         */
+        this.code = 0;
+        /**
+         * A developer-facing error message, which should be in English. Any
+         * user-facing error message should be localized and sent in the
+         * [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+         *
+         * @generated from field: string message = 2;
+         */
+        this.message = "";
+        /**
+         * A list of messages that carry the error details.  There will be a
+         * common set of message types for APIs to use.
+         *
+         * @generated from field: repeated google.protobuf.Any details = 3;
+         */
+        this.details = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new Status().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Status().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Status().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Status, a, b);
+    }
+}
+Status.runtime = proto3;
+Status.typeName = "google.rpc.Status";
+Status.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "code", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "details", kind: "message", T: Any, repeated: true },
+]);

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/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 handlers.
+ */
+export declare function createHandlerFactory(options: Partial<UniversalHandlerOptions>): ProtocolHandlerFactory;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/handler-factory.js

@@ -0,0 +1,119 @@
+// 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.
+import { createHandlerContext } from "../implementation.js";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+import { contentTypeJson, contentTypeProto, contentTypeRegExp, parseContentType, } from "./content-type.js";
+import { headerAcceptEncoding, headerContentType, headerEncoding, headerGrpcStatus, headerTimeout, } from "./headers.js";
+import { grpcStatusOk, setTrailerStatus } from "./trailer-status.js";
+import { parseTimeout } from "./parse-timeout.js";
+import { pipe, transformPrepend, transformSplitEnvelope, transformDecompressEnvelope, transformParseEnvelope, transformSerializeEnvelope, transformCompressEnvelope, transformJoinEnvelopes, transformCatchFinally, untilFirst, } from "../protocol/async-iterable.js";
+import { compressionNegotiate } from "../protocol/compression.js";
+import { contentTypeMatcher } from "../protocol/content-type-matcher.js";
+import { createMethodUrl } from "../protocol/create-method-url.js";
+import { transformInvokeImplementation } from "../protocol/invoke-implementation.js";
+import { createMethodSerializationLookup } from "../protocol/serialization.js";
+import { validateUniversalHandlerOptions } from "../protocol/universal-handler.js";
+import { assertByteStreamRequest, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseOk, } from "../protocol/universal.js";
+const protocolName = "grpc";
+const methodPost = "POST";
+/**
+ * Create a factory that creates gRPC handlers.
+ */
+export function createHandlerFactory(options) {
+    const opt = validateUniversalHandlerOptions(options);
+    function fact(spec) {
+        const h = createHandler(opt, spec);
+        return Object.assign(h, {
+            protocolNames: [protocolName],
+            allowedMethods: [methodPost],
+            supportedContentType: contentTypeMatcher(contentTypeRegExp),
+            requestPath: createMethodUrl("/", spec.service, spec.method),
+            service: spec.service,
+            method: spec.method,
+        });
+    }
+    fact.protocolName = protocolName;
+    return fact;
+}
+function createHandler(opt, spec) {
+    const serialization = createMethodSerializationLookup(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
+    return async function handle(req) {
+        assertByteStreamRequest(req);
+        const type = parseContentType(req.header.get(headerContentType));
+        if (type == undefined) {
+            return uResponseUnsupportedMediaType;
+        }
+        if (req.method !== methodPost) {
+            return uResponseMethodNotAllowed;
+        }
+        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
+        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headerContentType]: type.binary ? contentTypeProto : contentTypeJson,
+            }, responseTrailer: {
+                [headerGrpcStatus]: grpcStatusOk,
+            }, contextValues: req.contextValues }));
+        const compression = compressionNegotiate(opt.acceptCompression, req.header.get(headerEncoding), req.header.get(headerAcceptEncoding), headerAcceptEncoding);
+        if (compression.response) {
+            context.responseHeader.set(headerEncoding, compression.response.name);
+        }
+        // We split the pipeline into two parts: The request iterator, and the
+        // response iterator. We do this because the request iterator is responsible
+        // for parsing the request body, and we don't want write errors of the response
+        // iterator to affect the request iterator.
+        const inputIt = pipe(req.body, transformPrepend(() => {
+            // raise compression error to serialize it as a trailer status
+            if (compression.error)
+                throw compression.error;
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error)
+                throw timeout.error;
+            return undefined;
+        }), transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression.request, opt.readMaxBytes), transformParseEnvelope(serialization.getI(type.binary)));
+        const it = transformInvokeImplementation(spec, context, opt.interceptors)(inputIt)[Symbol.asyncIterator]();
+        const outputIt = pipe(
+        // We wrap the iterator in an async iterator to ensure that the
+        // abort signal is aborted when the iterator is done.
+        {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => it.next(),
+                    throw: (e) => {
+                        var _a, _b;
+                        context.abort(e);
+                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
+                    },
+                    return: (v) => {
+                        var _a, _b;
+                        context.abort();
+                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
+                    },
+                };
+            },
+        }, transformSerializeEnvelope(serialization.getO(type.binary)), transformCompressEnvelope(compression.response, opt.compressMinBytes), transformJoinEnvelopes(), transformCatchFinally((e) => {
+            context.abort();
+            if (e instanceof ConnectError) {
+                setTrailerStatus(context.responseTrailer, e);
+            }
+            else if (e !== undefined) {
+                setTrailerStatus(context.responseTrailer, new ConnectError("internal error", Code.Internal, undefined, undefined, e));
+            }
+        }), { propagateDownStreamError: true });
+        return Object.assign(Object.assign({}, uResponseOk), { 
+            // We wait for the first response body bytes before resolving, so that
+            // implementations have a chance to add headers before an adapter commits
+            // them to the wire.
+            body: await untilFirst(outputIt), header: context.responseHeader, trailer: context.responseTrailer });
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/headers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerContentType = "Content-Type";
+export declare const headerEncoding = "Grpc-Encoding";
+export declare const headerAcceptEncoding = "Grpc-Accept-Encoding";
+export declare const headerTimeout = "Grpc-Timeout";
+export declare const headerGrpcStatus = "Grpc-Status";
+export declare const headerGrpcMessage = "Grpc-Message";
+export declare const headerStatusDetailsBin = "Grpc-Status-Details-Bin";
+export declare const headerMessageType = "Grpc-Message-Type";
+export declare const headerUserAgent = "User-Agent";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/headers.js

@@ -0,0 +1,25 @@
+// 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.
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const headerContentType = "Content-Type";
+export const headerEncoding = "Grpc-Encoding";
+export const headerAcceptEncoding = "Grpc-Accept-Encoding";
+export const headerTimeout = "Grpc-Timeout";
+export const headerGrpcStatus = "Grpc-Status";
+export const headerGrpcMessage = "Grpc-Message";
+export const headerStatusDetailsBin = "Grpc-Status-Details-Bin";
+export const headerMessageType = "Grpc-Message-Type";
+export const headerUserAgent = "User-Agent";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/http-status.d.ts

@@ -0,0 +1,8 @@
+import { Code } from "../code.js";
+/**
+ * Determine the gRPC-web error code for the given HTTP status code.
+ * See https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeFromHttpStatus(httpStatus: number): Code;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/http-status.js

@@ -0,0 +1,43 @@
+// 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.
+import { Code } from "../code.js";
+/**
+ * Determine the gRPC-web error code for the given HTTP status code.
+ * See https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function codeFromHttpStatus(httpStatus) {
+    switch (httpStatus) {
+        case 400: // Bad Request
+            return Code.Internal;
+        case 401: // Unauthorized
+            return Code.Unauthenticated;
+        case 403: // Forbidden
+            return Code.PermissionDenied;
+        case 404: // Not Found
+            return Code.Unimplemented;
+        case 429: // Too Many Requests
+            return Code.Unavailable;
+        case 502: // Bad Gateway
+            return Code.Unavailable;
+        case 503: // Service Unavailable
+            return Code.Unavailable;
+        case 504: // Gateway Timeout
+            return Code.Unavailable;
+        default:
+            // 200 is UNKNOWN because there should be a grpc-status in case of truly OK response.
+            return Code.Unknown;
+    }
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/index.d.ts

@@ -0,0 +1,10 @@
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+export { codeFromHttpStatus } from "./http-status.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { parseContentType, contentTypeRegExp, contentTypeJson, contentTypeProto, } from "./content-type.js";
+export { parseTimeout } from "./parse-timeout.js";
+export { findTrailerError, setTrailerStatus, grpcStatusOk, } from "./trailer-status.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { validateTrailer } from "./validate-trailer.js";
+export * from "./headers.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/index.js

@@ -0,0 +1,28 @@
+// 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.
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+// 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 ^).
+export { codeFromHttpStatus } from "./http-status.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { parseContentType, contentTypeRegExp, contentTypeJson, contentTypeProto, } from "./content-type.js";
+export { parseTimeout } from "./parse-timeout.js";
+export { findTrailerError, setTrailerStatus, grpcStatusOk, } from "./trailer-status.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { validateTrailer } from "./validate-trailer.js";
+export * from "./headers.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/parse-timeout.d.ts

@@ -0,0 +1,13 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a gRPC Timeout (Deadline) header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseTimeout(value: string | null, maxTimeoutMs: number): {
+    timeoutMs?: number;
+    error?: undefined;
+} | {
+    timeoutMs?: number;
+    error: ConnectError;
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/parse-timeout.js

@@ -0,0 +1,50 @@
+// 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.
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a gRPC Timeout (Deadline) header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseTimeout(value, maxTimeoutMs) {
+    if (value === null) {
+        return {};
+    }
+    const results = /^(\d{1,8})([HMSmun])$/.exec(value);
+    if (results === null) {
+        return {
+            error: new ConnectError(`protocol error: invalid grpc timeout value: ${value}`, Code.InvalidArgument),
+        };
+    }
+    const unitToMultiplicand = {
+        H: 60 * 60 * 1000, // hour
+        M: 60 * 1000, // minute
+        S: 1000, // second
+        m: 1, // millisecond
+        u: 0.001, // microsecond
+        n: 0.000001, // nanosecond
+    };
+    const timeoutMs = unitToMultiplicand[results[2]] *
+        parseInt(results[1]);
+    if (timeoutMs > maxTimeoutMs) {
+        return {
+            timeoutMs: timeoutMs,
+            error: new ConnectError(`timeout ${timeoutMs}ms must be <= ${maxTimeoutMs}`, Code.InvalidArgument),
+        };
+    }
+    return {
+        timeoutMs,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/request-header.d.ts

@@ -0,0 +1,13 @@
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Creates headers for a gRPC request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeader(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined): Headers;
+/**
+ * Creates headers for a gRPC request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeaderWithCompression(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, acceptCompression: Compression[], sendCompression: Compression | null): Headers;

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

@@ -0,0 +1,52 @@
+// 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.
+import { headerAcceptEncoding, headerContentType, headerEncoding, headerTimeout, headerUserAgent, } from "./headers.js";
+import { contentTypeJson, contentTypeProto } from "./content-type.js";
+/**
+ * Creates headers for a gRPC request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders) {
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    result.set(headerContentType, useBinaryFormat ? contentTypeProto : contentTypeJson);
+    if (!result.has(headerUserAgent)) {
+        // Note that we do not strictly comply with gRPC user agents.
+        // We use "connect-es/1.2.3" where gRPC would use "grpc-es/1.2.3".
+        // See https://github.com/grpc/grpc/blob/c462bb8d485fc1434ecfae438823ca8d14cf3154/doc/PROTOCOL-HTTP2.md#user-agents
+        result.set(headerUserAgent, "connect-es/1.7.0");
+    }
+    if (timeoutMs !== undefined) {
+        result.set(headerTimeout, `${timeoutMs}m`);
+    }
+    // The gRPC-HTTP2 specification requires this - it flushes out proxies that
+    // don't support HTTP trailers.
+    result.set("Te", "trailers");
+    return result;
+}
+/**
+ * Creates headers for a gRPC request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeaderWithCompression(useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression) {
+    const result = requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders);
+    if (sendCompression != null) {
+        result.set(headerEncoding, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        result.set(headerAcceptEncoding, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/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/esm/protocol-grpc/trailer-status.js

@@ -0,0 +1,99 @@
+// 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.
+import { Any } from "@bufbuild/protobuf";
+import { Status } from "./gen/status_pb.js";
+import { ConnectError } from "../connect-error.js";
+import { decodeBinaryHeader, encodeBinaryHeader } from "../http-headers.js";
+import { Code } from "../code.js";
+import { headerGrpcMessage, headerGrpcStatus, headerStatusDetailsBin, } from "./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.
+ */
+export 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 function setTrailerStatus(target, error) {
+    if (error) {
+        target.set(headerGrpcStatus, error.code.toString(10));
+        target.set(headerGrpcMessage, encodeURIComponent(error.rawMessage));
+        if (error.details.length > 0) {
+            const status = new Status({
+                code: error.code,
+                message: error.rawMessage,
+                details: error.details.map((value) => "getType" in value
+                    ? Any.pack(value)
+                    : new Any({
+                        typeUrl: `type.googleapis.com/${value.type}`,
+                        value: value.value,
+                    })),
+            });
+            target.set(headerStatusDetailsBin, encodeBinaryHeader(status));
+        }
+    }
+    else {
+        target.set(headerGrpcStatus, 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.
+ */
+export 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(headerStatusDetailsBin);
+    if (statusBytes != null) {
+        const status = decodeBinaryHeader(statusBytes, Status);
+        if (status.code == 0) {
+            return undefined;
+        }
+        const error = new 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(headerGrpcStatus);
+    if (grpcStatus != null) {
+        if (grpcStatus === grpcStatusOk) {
+            return undefined;
+        }
+        const code = parseInt(grpcStatus, 10);
+        if (code in Code) {
+            return new ConnectError(decodeURIComponent((_a = headerOrTrailer.get(headerGrpcMessage)) !== null && _a !== void 0 ? _a : ""), code, headerOrTrailer);
+        }
+        return new ConnectError(`invalid grpc-status: ${grpcStatus}`, Code.Internal, headerOrTrailer);
+    }
+    return undefined;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/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;