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

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

@@ -0,0 +1,92 @@
+"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.Code = void 0;
+/**
+ * Connect represents categories of errors as codes, and each code maps to a
+ * specific HTTP status code. The codes and their semantics were chosen to
+ * match gRPC. Only the codes below are valid — there are no user-defined
+ * codes.
+ *
+ * See the specification at https://connectrpc.com/docs/protocol#error-codes
+ * for details.
+ */
+var Code;
+(function (Code) {
+    /**
+     * Canceled, usually be the user
+     */
+    Code[Code["Canceled"] = 1] = "Canceled";
+    /**
+     * Unknown error
+     */
+    Code[Code["Unknown"] = 2] = "Unknown";
+    /**
+     * Argument invalid regardless of system state
+     */
+    Code[Code["InvalidArgument"] = 3] = "InvalidArgument";
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    Code[Code["DeadlineExceeded"] = 4] = "DeadlineExceeded";
+    /**
+     * Entity not found.
+     */
+    Code[Code["NotFound"] = 5] = "NotFound";
+    /**
+     * Entity already exists.
+     */
+    Code[Code["AlreadyExists"] = 6] = "AlreadyExists";
+    /**
+     * Operation not authorized.
+     */
+    Code[Code["PermissionDenied"] = 7] = "PermissionDenied";
+    /**
+     * Quota exhausted.
+     */
+    Code[Code["ResourceExhausted"] = 8] = "ResourceExhausted";
+    /**
+     * Argument invalid in current system state.
+     */
+    Code[Code["FailedPrecondition"] = 9] = "FailedPrecondition";
+    /**
+     * Operation aborted.
+     */
+    Code[Code["Aborted"] = 10] = "Aborted";
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    Code[Code["OutOfRange"] = 11] = "OutOfRange";
+    /**
+     * Operation not implemented or disabled.
+     */
+    Code[Code["Unimplemented"] = 12] = "Unimplemented";
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Code[Code["Internal"] = 13] = "Internal";
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Code[Code["Unavailable"] = 14] = "Unavailable";
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    Code[Code["DataLoss"] = 15] = "DataLoss";
+    /**
+     * Request isn't authenticated.
+     */
+    Code[Code["Unauthenticated"] = 16] = "Unauthenticated";
+})(Code || (exports.Code = Code = {}));

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

@@ -0,0 +1,90 @@
+import { Code } from "./code.js";
+import type { Message, AnyMessage, IMessageTypeRegistry, JsonValue, MessageType } from "@bufbuild/protobuf";
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+export declare class ConnectError extends Error {
+    /**
+     * The Code for this error.
+     */
+    readonly code: Code;
+    /**
+     * A union of response headers and trailers associated with this error.
+     */
+    readonly metadata: Headers;
+    /**
+     * When an error is parsed from the wire, incoming error details are stored
+     * in this property. They can be retrieved using findDetails().
+     *
+     * When an error is constructed to be sent over the wire, outgoing error
+     * details are stored in this property as well.
+     */
+    details: (Message | IncomingDetail)[];
+    /**
+     * The error message, but without a status code in front.
+     *
+     * For example, a new `ConnectError("hello", Code.NotFound)` will have
+     * the message `[not found] hello`, and the rawMessage `hello`.
+     */
+    readonly rawMessage: string;
+    name: string;
+    /**
+     * The underlying cause of this error, if any. In cases where the actual cause
+     * is elided with the error message, the cause is specified here so that we
+     * don't leak the underlying error, but instead make it available for logging.
+     */
+    cause: unknown;
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with error.
+     */
+    constructor(message: string, code?: Code, metadata?: HeadersInit, outgoingDetails?: Message[], cause?: unknown);
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError from the fetch API, return the message
+     *   of the AbortError with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason: unknown, code?: Code): ConnectError;
+    static [Symbol.hasInstance](v: unknown): boolean;
+    /**
+     * Retrieve error details from a ConnectError. On the wire, error details are
+     * wrapped with google.protobuf.Any, so that a server or middleware can attach
+     * arbitrary data to an error. This function decodes the array of error details
+     * from the ConnectError object, and returns an array with the decoded
+     * messages. Any decoding errors are ignored, and the detail will simply be
+     * omitted from the list.
+     */
+    findDetails<T extends Message<T>>(type: MessageType<T>): T[];
+    findDetails(registry: IMessageTypeRegistry): AnyMessage[];
+}
+/**
+ * An incoming detail is basically a google.protobuf.Any, but it includes an
+ * optional JSON representation in the "debug" key, and stores a type name
+ * instead of a type URL.
+ */
+type IncomingDetail = {
+    type: string;
+    value: Uint8Array;
+    debug?: JsonValue;
+};
+export {};

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

@@ -0,0 +1,134 @@
+"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.ConnectError = void 0;
+const code_js_1 = require("./code.js");
+const code_string_js_1 = require("./protocol-connect/code-string.js");
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+class ConnectError extends Error {
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with error.
+     */
+    constructor(message, code = code_js_1.Code.Unknown, metadata, outgoingDetails, cause) {
+        super(createMessage(message, code));
+        this.name = "ConnectError";
+        // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.rawMessage = message;
+        this.code = code;
+        this.metadata = new Headers(metadata !== null && metadata !== void 0 ? metadata : {});
+        this.details = outgoingDetails !== null && outgoingDetails !== void 0 ? outgoingDetails : [];
+        this.cause = cause;
+    }
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError from the fetch API, return the message
+     *   of the AbortError with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason, code = code_js_1.Code.Unknown) {
+        if (reason instanceof ConnectError) {
+            return reason;
+        }
+        if (reason instanceof Error) {
+            if (reason.name == "AbortError") {
+                // Fetch requests can only be canceled with an AbortController.
+                // We detect that condition by looking at the name of the raised
+                // error object, and translate to the appropriate status code.
+                return new ConnectError(reason.message, code_js_1.Code.Canceled);
+            }
+            return new ConnectError(reason.message, code, undefined, undefined, reason);
+        }
+        return new ConnectError(String(reason), code, undefined, undefined, reason);
+    }
+    static [Symbol.hasInstance](v) {
+        if (!(v instanceof Error)) {
+            return false;
+        }
+        if (Object.getPrototypeOf(v) === ConnectError.prototype) {
+            return true;
+        }
+        return (v.name === "ConnectError" &&
+            "code" in v &&
+            typeof v.code === "number" &&
+            "metadata" in v &&
+            "details" in v &&
+            Array.isArray(v.details) &&
+            "rawMessage" in v &&
+            typeof v.rawMessage == "string" &&
+            "cause" in v);
+    }
+    findDetails(typeOrRegistry) {
+        const registry = "typeName" in typeOrRegistry
+            ? {
+                findMessage: (typeName) => typeName === typeOrRegistry.typeName ? typeOrRegistry : undefined,
+            }
+            : typeOrRegistry;
+        const details = [];
+        for (const data of this.details) {
+            if ("getType" in data) {
+                if (registry.findMessage(data.getType().typeName)) {
+                    details.push(data);
+                }
+                continue;
+            }
+            const type = registry.findMessage(data.type);
+            if (type) {
+                try {
+                    details.push(type.fromBinary(data.value));
+                }
+                catch (_) {
+                    // We silently give up if we are unable to parse the detail, because
+                    // that appears to be the least worst behavior.
+                    // It is very unlikely that a user surrounds a catch body handling the
+                    // error with another try-catch statement, and we do not want to
+                    // recommend doing so.
+                }
+            }
+        }
+        return details;
+    }
+}
+exports.ConnectError = ConnectError;
+/**
+ * Create an error message, prefixing the given code.
+ */
+function createMessage(message, code) {
+    return message.length
+        ? `[${(0, code_string_js_1.codeToString)(code)}] ${message}`
+        : `[${(0, code_string_js_1.codeToString)(code)}]`;
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/context-values.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ContextValues is a collection of context values.
+ */
+export interface ContextValues {
+    /**
+     * get returns a context value.
+     */
+    get<T>(key: ContextKey<T>): T;
+    /**
+     * set sets a context value. It returns the ContextValues to allow chaining.
+     */
+    set<T>(key: ContextKey<T>, value: T): this;
+    /**
+     * delete deletes a context value. It returns the ContextValues to allow chaining.
+     */
+    delete(key: ContextKey<unknown>): this;
+}
+/**
+ * createContextValues creates a new ContextValues.
+ */
+export declare function createContextValues(): ContextValues;
+/**
+ * ContextKey is a unique identifier for a context value.
+ */
+export type ContextKey<T> = {
+    id: symbol;
+    defaultValue: T;
+};
+/**
+ * createContextKey creates a new ContextKey.
+ */
+export declare function createContextKey<T>(defaultValue: T, options?: {
+    description?: string;
+}): ContextKey<T>;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/context-values.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.createContextValues = createContextValues;
+exports.createContextKey = createContextKey;
+/**
+ * createContextValues creates a new ContextValues.
+ */
+function createContextValues() {
+    return {
+        get(key) {
+            return key.id in this ? this[key.id] : key.defaultValue;
+        },
+        set(key, value) {
+            this[key.id] = value;
+            return this;
+        },
+        delete(key) {
+            delete this[key.id];
+            return this;
+        },
+    };
+}
+/**
+ * createContextKey creates a new ContextKey.
+ */
+function createContextKey(defaultValue, options) {
+    return { id: Symbol(options === null || options === void 0 ? void 0 : options.description), defaultValue };
+}

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

@@ -0,0 +1,45 @@
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export declare const cors: {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: ReadonlyArray<string>;
+};

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

@@ -0,0 +1,82 @@
+"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.cors = void 0;
+const connect = require("./protocol-connect/headers.js");
+const grpc = require("./protocol-grpc/headers.js");
+const grpcWeb = require("./protocol-grpc-web/headers.js");
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+exports.cors = {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ["POST", "GET"],
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: [
+        connect.headerContentType,
+        connect.headerProtocolVersion,
+        connect.headerTimeout,
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerUnaryAcceptEncoding, // Unused in web browsers, but added for future-proofing
+        grpc.headerMessageType, // Unused in web browsers, but added for future-proofing
+        grpcWeb.headerXGrpcWeb,
+        grpcWeb.headerXUserAgent,
+        grpcWeb.headerTimeout,
+    ],
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: [
+        grpcWeb.headerGrpcStatus, // Crucial for gRPC-web
+        grpcWeb.headerGrpcMessage, // Crucial for gRPC-web
+        grpcWeb.headerStatusDetailsBin, // Error details in gRPC, gRPC-web
+        connect.headerUnaryEncoding, // Unused in web browsers, but added for future-proofing
+        connect.headerStreamEncoding, // Unused in web browsers, but added for future-proofing
+    ],
+};

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/http-headers.d.ts

@@ -0,0 +1,36 @@
+import type { Message, BinaryReadOptions, MessageType } from "@bufbuild/protobuf";
+/**
+ * Encode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function accepts raw binary data from a buffer, a string
+ * with UTF-8 text, or a protobuf message. It encodes the input
+ * with unpadded base64 and returns a string that can be used for
+ * a header whose name ends with `-bin`.
+ */
+export declare function encodeBinaryHeader(value: Uint8Array | ArrayBufferLike | Message | string): string;
+/**
+ * Decode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function returns the raw binary data from a header whose
+ * name ends with `-bin`. If given a message type in the second
+ * argument, it deserializes a protobuf message. To decode a value
+ * that contains unicode text, pass the raw binary data returned
+ * from this function through TextDecoder.decode.
+ *
+ * Note that duplicate header names may have their values joined
+ * with a `,` as the delimiter, so you most likely will want to
+ * split by `,` first.
+ *
+ * If this function detects invalid base-64 encoding, or invalid
+ * binary message data, it throws a ConnectError with code
+ * DataLoss.
+ */
+export declare function decodeBinaryHeader(value: string): Uint8Array;
+export declare function decodeBinaryHeader<T extends Message<T>>(value: string, type: MessageType<T>, options?: Partial<BinaryReadOptions>): T;
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+export declare function appendHeaders(...headers: Headers[]): Headers;

package/gen/ts/node_modules/@connectrpc/connect/dist/cjs/http-headers.js

@@ -0,0 +1,68 @@
+"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.encodeBinaryHeader = encodeBinaryHeader;
+exports.decodeBinaryHeader = decodeBinaryHeader;
+exports.appendHeaders = appendHeaders;
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_error_js_1 = require("./connect-error.js");
+const code_js_1 = require("./code.js");
+/**
+ * Encode a single binary header value according to the Connect
+ * and gRPC specifications.
+ *
+ * This function accepts raw binary data from a buffer, a string
+ * with UTF-8 text, or a protobuf message. It encodes the input
+ * with unpadded base64 and returns a string that can be used for
+ * a header whose name ends with `-bin`.
+ */
+function encodeBinaryHeader(value) {
+    let bytes;
+    if (typeof value == "object" && "getType" in value) {
+        bytes = value.toBinary();
+    }
+    else if (typeof value == "string") {
+        bytes = new TextEncoder().encode(value);
+    }
+    else {
+        bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    }
+    return protobuf_1.protoBase64.enc(bytes).replace(/=+$/, "");
+}
+function decodeBinaryHeader(value, type, options) {
+    try {
+        const bytes = protobuf_1.protoBase64.dec(value);
+        if (type) {
+            return type.fromBinary(bytes, options);
+        }
+        return bytes;
+    }
+    catch (e) {
+        throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.DataLoss);
+    }
+}
+/**
+ * Merge two or more Headers objects by appending all fields from
+ * all inputs to a new Headers object.
+ */
+function appendHeaders(...headers) {
+    const h = new Headers();
+    for (const e of headers) {
+        e.forEach((value, key) => {
+            h.append(key, value);
+        });
+    }
+    return h;
+}