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

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto-double.js

@@ -0,0 +1,26 @@
+// 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 global Number constants. This is done so that we can safely use
+// these global constants when generating code and be assured we're using
+// the correct values. We cannot rely on globalThis since we support ES2017
+// and globalThis was introduced in ES2020. We also don't want to explicitly
+// generate code using, for example, Number.NaN, since this could clash with
+// a message name of Number. Instead we can export them here since this will
+// be in a different scope as the generated code and we are guaranteed to use
+// the intended global values.
+export const protoDouble = {
+    NaN: Number.NaN,
+    POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
+    NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.d.ts

@@ -0,0 +1,95 @@
+/**
+ * We use the `bigint` primitive to represent 64-bit integral types. If bigint
+ * is unavailable, we fall back to a string representation, which means that
+ * all values typed as `bigint` will actually be strings.
+ *
+ * If your code is intended to run in an environment where bigint may be
+ * unavailable, it must handle both the bigint and the string representation.
+ * For presenting values, this is straight-forward with implicit or explicit
+ * conversion to string:
+ *
+ * ```ts
+ * let el = document.createElement("span");
+ * el.innerText = message.int64Field; // assuming a protobuf int64 field
+ *
+ * console.log(`int64: ${message.int64Field}`);
+ *
+ * let str: string = message.int64Field.toString();
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values and are sure the values
+ * can be safely represented as an IEEE-754 double precision number, you can
+ * convert to a JavaScript Number:
+ *
+ * ```ts
+ * console.log(message.int64Field.toString())
+ * let num = Number(message.int64Field);
+ * num = num + 1;
+ * message.int64Field = protoInt64.parse(num);
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values that are outside the
+ * range of safe representation as a JavaScript Number, we recommend you
+ * use a third party library, for example the npm package "long":
+ *
+ * ```ts
+ * // convert the field value to a Long
+ * const bits = protoInt64.enc(message.int64Field);
+ * const longValue = Long.fromBits(bits.lo, bits.hi);
+ *
+ * // perform arithmetic
+ * const longResult = longValue.subtract(1);
+ *
+ * // set the result in the field
+ * message.int64Field = protoInt64.dec(longResult.low, longResult.high);
+ *
+ * // Assuming int64Field contains 9223372036854775807:
+ * console.log(message.int64Field); // 9223372036854775806
+ * ```
+ */
+interface Int64Support {
+    /**
+     * 0n if bigint is available, "0" if unavailable.
+     */
+    readonly zero: bigint;
+    /**
+     * Is bigint available?
+     */
+    readonly supported: boolean;
+    /**
+     * Parse a signed 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    parse(value: string | number | bigint): bigint;
+    /**
+     * Parse an unsigned 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uParse(value: string | number | bigint): bigint;
+    /**
+     * Convert a signed 64-bit integral value to a two's complement.
+     */
+    enc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert an unsigned 64-bit integral value to a two's complement.
+     */
+    uEnc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert a two's complement to a signed 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    dec(lo: number, hi: number): bigint;
+    /**
+     * Convert a two's complement to an unsigned 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uDec(lo: number, hi: number): bigint;
+}
+export declare const protoInt64: Int64Support;
+export {};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js

@@ -0,0 +1,113 @@
+// 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.
+import { assert } from "./private/assert.js";
+import { int64FromString, int64ToString, uInt64ToString, } from "./google/varint.js";
+function makeInt64Support() {
+    const dv = new DataView(new ArrayBuffer(8));
+    // note that Safari 14 implements BigInt, but not the DataView methods
+    const ok = typeof BigInt === "function" &&
+        typeof dv.getBigInt64 === "function" &&
+        typeof dv.getBigUint64 === "function" &&
+        typeof dv.setBigInt64 === "function" &&
+        typeof dv.setBigUint64 === "function" &&
+        (typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
+    if (ok) {
+        const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
+        return {
+            zero: BigInt(0),
+            supported: true,
+            parse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > MAX || bi < MIN) {
+                    throw new Error(`int64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            uParse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > UMAX || bi < UMIN) {
+                    throw new Error(`uint64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            enc(value) {
+                dv.setBigInt64(0, this.parse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            uEnc(value) {
+                dv.setBigInt64(0, this.uParse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            dec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigInt64(0, true);
+            },
+            uDec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigUint64(0, true);
+            },
+        };
+    }
+    const assertInt64String = (value) => assert(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`);
+    const assertUInt64String = (value) => assert(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`);
+    return {
+        zero: "0",
+        supported: false,
+        parse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return value;
+        },
+        uParse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return value;
+        },
+        enc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return int64FromString(value);
+        },
+        uEnc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return int64FromString(value);
+        },
+        dec(lo, hi) {
+            return int64ToString(lo, hi);
+        },
+        uDec(lo, hi) {
+            return uInt64ToString(lo, hi);
+        },
+    };
+}
+export const protoInt64 = makeInt64Support();

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto2.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provides functionality for messages defined with the proto2 syntax.
+ */
+export declare const proto2: import("./private/proto-runtime.js").ProtoRuntime;

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto2.js

@@ -0,0 +1,50 @@
+// 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.
+import { makeProtoRuntime } from "./private/proto-runtime.js";
+import { InternalFieldList } from "./private/field-list.js";
+import { normalizeFieldInfos } from "./private/field-normalize.js";
+/**
+ * Provides functionality for messages defined with the proto2 syntax.
+ */
+export const proto2 = makeProtoRuntime("proto2", (fields) => {
+    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, false));
+}, 
+// TODO merge with proto3 and initExtensionField, also see initPartial, equals, clone
+(target) => {
+    for (const member of target.getType().fields.byMember()) {
+        const name = member.localName, t = target;
+        if (member.repeated) {
+            t[name] = [];
+            continue;
+        }
+        switch (member.kind) {
+            case "oneof":
+                t[name] = { case: undefined };
+                break;
+            case "map":
+                t[name] = {};
+                break;
+            case "scalar":
+            case "enum":
+            case "message":
+                // In contrast to proto3, enum and scalar fields have no intrinsic default value,
+                // only an optional explicit default value.
+                // Unlike proto3 intrinsic default values, proto2 explicit default values are not
+                // set on construction, because they are not omitted on the wire. If we did set
+                // default values on construction, a deserialize-serialize round-trip would add
+                // fields to a message.
+                break;
+        }
+    }
+});

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto3.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provides functionality for messages defined with the proto3 syntax.
+ */
+export declare const proto3: import("./private/proto-runtime.js").ProtoRuntime;

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/proto3.js

@@ -0,0 +1,53 @@
+// 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.
+import { makeProtoRuntime } from "./private/proto-runtime.js";
+import { InternalFieldList } from "./private/field-list.js";
+import { scalarZeroValue } from "./private/scalars.js";
+import { normalizeFieldInfos } from "./private/field-normalize.js";
+/**
+ * Provides functionality for messages defined with the proto3 syntax.
+ */
+export const proto3 = makeProtoRuntime("proto3", (fields) => {
+    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, true));
+}, 
+// TODO merge with proto2 and initExtensionField, also see initPartial, equals, clone
+(target) => {
+    for (const member of target.getType().fields.byMember()) {
+        if (member.opt) {
+            continue;
+        }
+        const name = member.localName, t = target;
+        if (member.repeated) {
+            t[name] = [];
+            continue;
+        }
+        switch (member.kind) {
+            case "oneof":
+                t[name] = { case: undefined };
+                break;
+            case "enum":
+                t[name] = 0;
+                break;
+            case "map":
+                t[name] = {};
+                break;
+            case "scalar":
+                t[name] = scalarZeroValue(member.T, member.L);
+                break;
+            case "message":
+                // message fields are always optional in proto3
+                break;
+        }
+    }
+});

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/scalar.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    BYTES = 12,
+    UINT32 = 13,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,// Uses ZigZag encoding.
+    SINT64 = 18
+}
+/**
+ * JavaScript representation of fields with 64 bit integral types (int64, uint64,
+ * sint64, fixed64, sfixed64).
+ *
+ * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
+ * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
+ * String if `[jstype = JS_STRING]` is specified.
+ *
+ * ```protobuf
+ * uint64 field_a = 1; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_STRING]; // String
+ * ```
+ */
+export declare enum LongType {
+    /**
+     * Use JavaScript BigInt.
+     */
+    BIGINT = 0,
+    /**
+     * Use JavaScript String.
+     *
+     * Field option `[jstype = JS_STRING]`.
+     */
+    STRING = 1
+}
+/**
+ * ScalarValue maps from a scalar field type to a TypeScript value type.
+ */
+export type ScalarValue<T = ScalarType, L extends LongType = LongType.STRING | LongType.BIGINT> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.SFIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.UINT64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.FIXED64 ? (L extends LongType.STRING ? string : bigint) : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/scalar.js

@@ -0,0 +1,78 @@
+// 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.
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export var ScalarType;
+(function (ScalarType) {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
+    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT64"] = 3] = "INT64";
+    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT32"] = 5] = "INT32";
+    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
+    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
+    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
+    ScalarType[ScalarType["STRING"] = 9] = "STRING";
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    // TYPE_GROUP = 10,
+    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
+    // New in version 2.
+    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
+    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
+    // TYPE_ENUM = 14,
+    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
+    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
+    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
+    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
+})(ScalarType || (ScalarType = {}));
+/**
+ * JavaScript representation of fields with 64 bit integral types (int64, uint64,
+ * sint64, fixed64, sfixed64).
+ *
+ * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
+ * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
+ * String if `[jstype = JS_STRING]` is specified.
+ *
+ * ```protobuf
+ * uint64 field_a = 1; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_STRING]; // String
+ * ```
+ */
+export var LongType;
+(function (LongType) {
+    /**
+     * Use JavaScript BigInt.
+     */
+    LongType[LongType["BIGINT"] = 0] = "BIGINT";
+    /**
+     * Use JavaScript String.
+     *
+     * Field option `[jstype = JS_STRING]`.
+     */
+    LongType[LongType["STRING"] = 1] = "STRING";
+})(LongType || (LongType = {}));

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

@@ -0,0 +1,96 @@
+import type { AnyMessage, Message } from "./message.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * ServiceType represents a protobuf services. It provides metadata for
+ * reflection-based operations.
+ */
+export interface ServiceType {
+    /**
+     * The fully qualified name of the service.
+     */
+    readonly typeName: string;
+    /**
+     * A map of local name (safe to use in ECMAScript) to method.
+     */
+    readonly methods: {
+        [localName: string]: MethodInfo;
+    };
+}
+/**
+ * MethodInfo represents a method of a protobuf service, a remote procedure
+ * call. All methods provide the following properties:
+ *
+ * - "name": The original name of the protobuf rpc.
+ * - "I": The input message type.
+ * - "O": The output message type.
+ * - "kind": The method type.
+ * - "idempotency": User-provided indication whether the method will cause
+ *   the same effect every time it is called.
+ */
+export type MethodInfo<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
+/**
+ * A unary method: rpc (Input) returns (Output)
+ */
+export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.Unary;
+}
+/**
+ * A server streaming method: rpc (Input) returns (stream Output)
+ */
+export interface MethodInfoServerStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ServerStreaming;
+}
+/**
+ * A client streaming method: rpc (stream Input) returns (Output)
+ */
+export interface MethodInfoClientStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ClientStreaming;
+}
+/**
+ * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
+ */
+export interface MethodInfoBiDiStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.BiDiStreaming;
+}
+interface miShared<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> {
+    readonly name: string;
+    readonly I: MessageType<I>;
+    readonly O: MessageType<O>;
+    readonly idempotency?: MethodIdempotency;
+}
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+export declare enum MethodKind {
+    Unary = 0,
+    ServerStreaming = 1,
+    ClientStreaming = 2,
+    BiDiStreaming = 3
+}
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+export declare enum MethodIdempotency {
+    /**
+     * Idempotent, no side effects.
+     */
+    NoSideEffects = 1,
+    /**
+     * Idempotent, but may have side effects.
+     */
+    Idempotent = 2
+}
+export {};

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

@@ -0,0 +1,50 @@
+// 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.
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+export var MethodKind;
+(function (MethodKind) {
+    MethodKind[MethodKind["Unary"] = 0] = "Unary";
+    MethodKind[MethodKind["ServerStreaming"] = 1] = "ServerStreaming";
+    MethodKind[MethodKind["ClientStreaming"] = 2] = "ClientStreaming";
+    MethodKind[MethodKind["BiDiStreaming"] = 3] = "BiDiStreaming";
+})(MethodKind || (MethodKind = {}));
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+export var MethodIdempotency;
+(function (MethodIdempotency) {
+    /**
+     * Idempotent, no side effects.
+     */
+    MethodIdempotency[MethodIdempotency["NoSideEffects"] = 1] = "NoSideEffects";
+    /**
+     * Idempotent, but may have side effects.
+     */
+    MethodIdempotency[MethodIdempotency["Idempotent"] = 2] = "Idempotent";
+})(MethodIdempotency || (MethodIdempotency = {}));

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

@@ -0,0 +1,12 @@
+import { Message } from "./message.js";
+import type { PlainMessage } from "./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 declare function toPlainMessage<T extends Message<T>>(message: T | PlainMessage<T>): PlainMessage<T>;