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

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/to-plain-message.js

@@ -0,0 +1,70 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
+import { Message } from "./message.js";
+import { isMessage } from "./is-message.js";
+/**
+ * toPlainMessage returns a new object by stripping
+ * all methods from a message, leaving only fields and
+ * oneof groups. It is recursive, meaning it applies this
+ * same logic to all nested message fields as well.
+ *
+ * If the argument is already a plain message, it is
+ * returned as-is.
+ */
+export function toPlainMessage(message) {
+    if (!isMessage(message)) {
+        return message;
+    }
+    const type = message.getType();
+    const target = {};
+    for (const member of type.fields.byMember()) {
+        const source = message[member.localName];
+        let copy;
+        if (member.repeated) {
+            copy = source.map((e) => toPlainValue(e));
+        }
+        else if (member.kind == "map") {
+            copy = {};
+            for (const [key, v] of Object.entries(source)) {
+                copy[key] = toPlainValue(v);
+            }
+        }
+        else if (member.kind == "oneof") {
+            const f = member.findField(source.case);
+            copy = f
+                ? { case: source.case, value: toPlainValue(source.value) }
+                : { case: undefined };
+        }
+        else {
+            copy = toPlainValue(source);
+        }
+        target[member.localName] = copy;
+    }
+    return target;
+}
+function toPlainValue(value) {
+    if (value === undefined) {
+        return value;
+    }
+    if (isMessage(value)) {
+        return toPlainMessage(value);
+    }
+    if (value instanceof Uint8Array) {
+        const c = new Uint8Array(value.byteLength);
+        c.set(value);
+        return c;
+    }
+    return value;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/type-registry.d.ts

@@ -0,0 +1,66 @@
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.js";
+import type { ServiceType } from "./service-type.js";
+import type { Extension } from "./extension.js";
+/**
+ * IMessageTypeRegistry provides look-up for message types.
+ *
+ * You can conveniently create a registry using the createRegistry()
+ * function:
+ *
+ * ```ts
+ * import { createRegistry } from "@bufbuild/protobuf";
+ * import { MyMessage, MyOtherMessage } from "./gen/my_message_pb.js";
+ *
+ * const reg: IMessageTypeRegistry = createRegistry(
+ *   MyMessage,
+ *   MyOtherMessage,
+ * );
+ * ```
+ */
+export interface IMessageTypeRegistry {
+    /**
+     * Find a message type by its protobuf type name.
+     */
+    findMessage(typeName: string): MessageType | undefined;
+}
+/**
+ * IEnumTypeRegistry provides look-up for enum types.
+ */
+export interface IEnumTypeRegistry {
+    /**
+     * Find an enum type by its protobuf type name.
+     */
+    findEnum(typeName: string): EnumType | undefined;
+}
+/**
+ * IServiceTypeRegistry provides look-up for service types.
+ */
+export interface IServiceTypeRegistry {
+    /**
+     * Find a service type by its protobuf type name.
+     */
+    findService(typeName: string): ServiceType | undefined;
+}
+/**
+ * IExtensionRegistry provides look-up for extensions.
+ */
+export interface IExtensionRegistry {
+    /**
+     * Find an extension by the extendee type name and the extension number.
+     */
+    findExtensionFor(extendee: string, no: number): Extension | undefined;
+    /**
+     * Find an extension type by its protobuf type name.
+     */
+    findExtension(typeName: string): Extension | undefined;
+}
+/**
+ * A registry that allows
+ */
+export interface IMutableRegistry extends IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry, IExtensionRegistry {
+    /**
+     * Adds the type to the registry.
+     */
+    add(type: MessageType | EnumType | ServiceType | Extension): void;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/type-registry.js

@@ -0,0 +1,14 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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 {};

package/gen/ts/node_modules/@bufbuild/protobuf/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@bufbuild/protobuf",
+  "version": "1.10.1",
+  "license": "(Apache-2.0 AND BSD-3-Clause)",
+  "description": "A complete implementation of Protocol Buffers in TypeScript, suitable for web browsers and Node.js.",
+  "keywords": [
+    "protobuf",
+    "schema",
+    "typescript",
+    "ecmascript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bufbuild/protobuf-es.git",
+    "directory": "packages/protobuf"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist/*",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs --declaration --declarationDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm": "../../node_modules/typescript/bin/tsc --project tsconfig.json --outDir ./dist/esm --declaration --declarationDir ./dist/esm",
+    "bootstrap:featureset-defaults": "upstream-inject-feature-defaults src/private/feature-set.ts",
+    "prebootstrap:wkt": "rm -rf .tmp && mkdir -p .tmp/google/protobuf && cp -rp src/google/protobuf/* .tmp/google/protobuf",
+    "bootstrap:wkt": "protoc --es_out=src --es_opt=bootstrap_wkt=true,ts_nocheck=false,target=ts --proto_path $(upstream-include wkt) $(upstream-files wkt) && license-header src/google/protobuf",
+    "postbootstrap:wkt": "diff >/dev/null -r .tmp/google/protobuf src/google/protobuf && cp -rp .tmp/google/protobuf/* src/google/protobuf || true",
+    "attw": "attw --pack"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "devDependencies": {
+    "upstream-protobuf": "*"
+  }
+}

package/gen/ts/node_modules/@connectrpc/connect/README.md

@@ -0,0 +1,62 @@
+# @connectrpc/connect
+
+Connect is a family of libraries for building type-safe APIs with different languages and platforms.
+[@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings them to TypeScript,
+the web browser, and to Node.js.
+
+With Connect, you define your schema first:
+
+```
+service ElizaService {
+  rpc Say(SayRequest) returns (SayResponse) {}
+}
+```
+
+And with the magic of code generation, this schema produces servers and clients:
+
+```ts
+const answer = await eliza.say({ sentence: "I feel happy." });
+console.log(answer);
+// {sentence: 'When you feel happy, what do you do?'}
+```
+
+Unlike REST, the RPCs you use with Connect are typesafe end to end, but they are
+regular HTTP under the hood. You can see all requests in the network inspector,
+and you can `curl` them if you want:
+
+```shell
+curl \
+    --header 'Content-Type: application/json' \
+    --data '{"sentence": "I feel happy."}' \
+    https://demo.connectrpc.com/connectrpc.eliza.v1.ElizaService/Say
+```
+
+With Connect for ECMAScript, you can spin up a service in Node.js and call it
+from the web, the terminal, or native mobile clients. Under the hood, it uses
+[Protocol Buffers](https://github.com/bufbuild/protobuf-es) for the schema, and
+implements RPC (remote procedure calls) with three protocols: The widely available
+gRPC and gRPC-web, and Connect's [own protocol](https://connectrpc.com/docs/protocol/),
+optimized for the web. This gives you unparalleled interoperability with
+full-stack type-safety.
+
+## Get started on the web
+
+Follow our [10 minute tutorial](https://connectrpc.com/docs/web/getting-started) where
+we use [Vite](https://vitejs.dev/) and [React](https://reactjs.org/) to create a
+web interface for ELIZA.
+
+**React**, **Svelte**, **Vue**, **Next.js** and **Angular** are supported (see [examples](https://github.com/connectrpc/examples-es)),
+and we have an expansion pack for [TanStack Query](https://github.com/connectrpc/connect-query-es).
+We support all modern web browsers that implement the widely available
+[fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+and the [Encoding API](https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API).
+
+## Get started on Node.js
+
+Follow our [10 minute tutorial](https://connectrpc.com/docs/node/getting-started)
+to spin up a service in Node.js, and call it from the web, and from a gRPC client
+in your terminal.
+
+You can use vanilla Node.js, or our server plugins for [Fastify](https://www.fastify.io/)
+or [Express](https://expressjs.com/). We support the builtin `http`, and `http2`
+modules on Node.js v16 and later.

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

@@ -0,0 +1,22 @@
+import type { ServiceType, MethodInfo } from "@bufbuild/protobuf";
+/**
+ * AnyClient is an arbitrary service client with any method signature.
+ *
+ * It usually has methods for all methods defined for a service, but may
+ * omit some, for example because it's transport does not support streaming.
+ */
+export type AnyClient = Record<string, AnyClientMethod>;
+type AnyClientMethod = (...args: any[]) => any;
+type CreateAnyClientMethod = (method: MethodInfo & {
+    localName: string;
+    service: ServiceType;
+}) => AnyClientMethod | null;
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+export declare function makeAnyClient(service: ServiceType, createMethod: CreateAnyClientMethod): AnyClient;
+export {};

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

@@ -0,0 +1,34 @@
+"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.makeAnyClient = makeAnyClient;
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+function makeAnyClient(service, createMethod) {
+    const client = {};
+    for (const [localName, methodInfo] of Object.entries(service.methods)) {
+        const method = createMethod(Object.assign(Object.assign({}, methodInfo), { localName,
+            service }));
+        if (method != null) {
+            client[localName] = method;
+        }
+    }
+    return client;
+}

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

@@ -0,0 +1,34 @@
+import type { ContextValues } from "./context-values.js";
+/**
+ * Options for a call. Every client should accept CallOptions as optional
+ * argument in its RPC methods.
+ */
+export interface CallOptions {
+    /**
+     * Timeout in milliseconds.
+     *
+     * Set to <= 0 to disable the default timeout.
+     */
+    timeoutMs?: number;
+    /**
+     * Custom headers to send with the request.
+     */
+    headers?: HeadersInit;
+    /**
+     * An optional AbortSignal to cancel the call.
+     * If cancelled, an error with Code.Canceled is raised.
+     */
+    signal?: AbortSignal;
+    /**
+     * Called when response headers are received.
+     */
+    onHeader?(headers: Headers): void;
+    /**
+     * Called when response trailers are received.
+     */
+    onTrailer?(trailers: Headers): void;
+    /**
+     * ContextValues to pass to the interceptors.
+     */
+    contextValues?: ContextValues;
+}

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

@@ -0,0 +1,15 @@
+"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 });

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

@@ -0,0 +1,31 @@
+import type { MethodInfoServerStreaming, MethodInfoUnary, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import { ConnectError } from "./connect-error.js";
+import type { Transport } from "./transport.js";
+import type { CallOptions } from "./call-options.js";
+/**
+ * CallbackClient is a simple client that supports unary and server
+ * streaming methods. Methods take callback functions, which will be
+ * called when a response message arrives, or an error occurs.
+ *
+ * Client methods return a function that cancels the call. This is a
+ * convenient alternative to creating a AbortController and passing
+ * its AbortSignal as an option to the method.
+ *
+ * If a call is cancelled by an AbortController or by the returned
+ * cancel-function, ConnectErrors with the code Canceled are
+ * silently discarded.
+ *
+ * CallbackClient is most convenient for use in React effects, where
+ * a function returned by the effect is called when the effect is
+ * torn down.
+ */
+export type CallbackClient<T extends ServiceType> = {
+    [P in keyof T["methods"]]: T["methods"][P] extends MethodInfoUnary<infer I, infer O> ? (request: PartialMessage<I>, callback: (error: ConnectError | undefined, response: O) => void, options?: CallOptions) => CancelFn : T["methods"][P] extends MethodInfoServerStreaming<infer I, infer O> ? (request: PartialMessage<I>, messageCallback: (response: O) => void, closeCallback: (error: ConnectError | undefined) => void, options?: CallOptions) => CancelFn : never;
+};
+type CancelFn = () => void;
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+export declare function createCallbackClient<T extends ServiceType>(service: T, transport: Transport): CallbackClient<T>;
+export {};

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

@@ -0,0 +1,116 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCallbackClient = createCallbackClient;
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_error_js_1 = require("./connect-error.js");
+const code_js_1 = require("./code.js");
+const any_client_js_1 = require("./any-client.js");
+const async_iterable_js_1 = require("./protocol/async-iterable.js");
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+function createCallbackClient(service, transport) {
+    return (0, any_client_js_1.makeAnyClient)(service, (method) => {
+        switch (method.kind) {
+            case protobuf_1.MethodKind.Unary:
+                return createUnaryFn(transport, service, method);
+            case protobuf_1.MethodKind.ServerStreaming:
+                return createServerStreamingFn(transport, service, method);
+            default:
+                return null;
+        }
+    });
+}
+function createUnaryFn(transport, service, method) {
+    return function (requestMessage, callback, options) {
+        const abort = new AbortController();
+        options = wrapSignal(abort, options);
+        transport
+            .unary(service, method, abort.signal, options.timeoutMs, options.headers, requestMessage, options.contextValues)
+            .then((response) => {
+            var _a, _b;
+            (_a = options.onHeader) === null || _a === void 0 ? void 0 : _a.call(options, response.header);
+            (_b = options.onTrailer) === null || _b === void 0 ? void 0 : _b.call(options, response.trailer);
+            callback(undefined, response.message);
+        }, (reason) => {
+            const err = connect_error_js_1.ConnectError.from(reason, code_js_1.Code.Internal);
+            if (err.code === code_js_1.Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user.
+                return;
+            }
+            callback(err, new method.O());
+        });
+        return () => abort.abort();
+    };
+}
+function createServerStreamingFn(transport, service, method) {
+    return function (input, onResponse, onClose, options) {
+        const abort = new AbortController();
+        async function run() {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            options = wrapSignal(abort, options);
+            const response = await transport.stream(service, method, options.signal, options.timeoutMs, options.headers, (0, async_iterable_js_1.createAsyncIterable)([input]), options.contextValues);
+            (_d = options.onHeader) === null || _d === void 0 ? void 0 : _d.call(options, response.header);
+            try {
+                for (var _f = true, _g = __asyncValues(response.message), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const message = _c;
+                    onResponse(message);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            (_e = options.onTrailer) === null || _e === void 0 ? void 0 : _e.call(options, response.trailer);
+            onClose(undefined);
+        }
+        run().catch((reason) => {
+            const err = connect_error_js_1.ConnectError.from(reason, code_js_1.Code.Internal);
+            if (err.code === code_js_1.Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user,
+                // but do invoke the close-callback.
+                onClose(undefined);
+            }
+            else {
+                onClose(err);
+            }
+        });
+        return () => abort.abort();
+    };
+}
+function wrapSignal(abort, options) {
+    if (options === null || options === void 0 ? void 0 : options.signal) {
+        options.signal.addEventListener("abort", () => abort.abort());
+        if (options.signal.aborted) {
+            abort.abort();
+        }
+    }
+    return Object.assign(Object.assign({}, options), { signal: abort.signal });
+}

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

@@ -0,0 +1,75 @@
+/**
+ * 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.
+ */
+export declare enum Code {
+    /**
+     * Canceled, usually be the user
+     */
+    Canceled = 1,
+    /**
+     * Unknown error
+     */
+    Unknown = 2,
+    /**
+     * Argument invalid regardless of system state
+     */
+    InvalidArgument = 3,
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    DeadlineExceeded = 4,
+    /**
+     * Entity not found.
+     */
+    NotFound = 5,
+    /**
+     * Entity already exists.
+     */
+    AlreadyExists = 6,
+    /**
+     * Operation not authorized.
+     */
+    PermissionDenied = 7,
+    /**
+     * Quota exhausted.
+     */
+    ResourceExhausted = 8,
+    /**
+     * Argument invalid in current system state.
+     */
+    FailedPrecondition = 9,
+    /**
+     * Operation aborted.
+     */
+    Aborted = 10,
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    OutOfRange = 11,
+    /**
+     * Operation not implemented or disabled.
+     */
+    Unimplemented = 12,
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Internal = 13,
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Unavailable = 14,
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    DataLoss = 15,
+    /**
+     * Request isn't authenticated.
+     */
+    Unauthenticated = 16
+}