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

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

@@ -0,0 +1,313 @@
+// Copyright 2008 Google Inc.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Code generated by the Protocol Buffer compiler is owned by the owner
+// of the input file used when generating it.  This code is not
+// standalone and requires a support library to be linked with it.  This
+// support library is itself covered by the above license.
+/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export function varint64read() {
+    let lowBits = 0;
+    let highBits = 0;
+    for (let shift = 0; shift < 28; shift += 7) {
+        let b = this.buf[this.pos++];
+        lowBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    let middleByte = this.buf[this.pos++];
+    // last four bits of the first 32 bit number
+    lowBits |= (middleByte & 0x0f) << 28;
+    // 3 upper bits are part of the next 32 bit number
+    highBits = (middleByte & 0x70) >> 4;
+    if ((middleByte & 0x80) == 0) {
+        this.assertBounds();
+        return [lowBits, highBits];
+    }
+    for (let shift = 3; shift <= 31; shift += 7) {
+        let b = this.buf[this.pos++];
+        highBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    throw new Error("invalid varint");
+}
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export function varint64write(lo, hi, bytes) {
+    for (let i = 0; i < 28; i = i + 7) {
+        const shift = lo >>> i;
+        const hasNext = !(shift >>> 7 == 0 && hi == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+    const hasMoreBits = !(hi >> 3 == 0);
+    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+    if (!hasMoreBits) {
+        return;
+    }
+    for (let i = 3; i < 31; i = i + 7) {
+        const shift = hi >>> i;
+        const hasNext = !(shift >>> 7 == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    bytes.push((hi >>> 31) & 0x01);
+}
+// constants for binary math
+const TWO_PWR_32_DBL = 0x100000000;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function int64FromString(dec) {
+    // Check for minus sign.
+    const minus = dec[0] === "-";
+    if (minus) {
+        dec = dec.slice(1);
+    }
+    // Work 6 decimal digits at a time, acting like we're converting base 1e6
+    // digits to binary. This is safe to do with floating point math because
+    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
+    const base = 1e6;
+    let lowBits = 0;
+    let highBits = 0;
+    function add1e6digit(begin, end) {
+        // Note: Number('') is 0.
+        const digit1e6 = Number(dec.slice(begin, end));
+        highBits *= base;
+        lowBits = lowBits * base + digit1e6;
+        // Carry bits from lowBits to
+        if (lowBits >= TWO_PWR_32_DBL) {
+            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+            lowBits = lowBits % TWO_PWR_32_DBL;
+        }
+    }
+    add1e6digit(-24, -18);
+    add1e6digit(-18, -12);
+    add1e6digit(-12, -6);
+    add1e6digit(-6);
+    return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function int64ToString(lo, hi) {
+    let bits = newBits(lo, hi);
+    // If we're treating the input as a signed value and the high bit is set, do
+    // a manual two's complement conversion before the decimal conversion.
+    const negative = (bits.hi & 0x80000000);
+    if (negative) {
+        bits = negate(bits.lo, bits.hi);
+    }
+    const result = uInt64ToString(bits.lo, bits.hi);
+    return negative ? "-" + result : result;
+}
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function uInt64ToString(lo, hi) {
+    ({ lo, hi } = toUnsigned(lo, hi));
+    // Skip the expensive conversion if the number is small enough to use the
+    // built-in conversions.
+    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
+    // highBits <= 0x1FFFFF can be safely expressed with a double and retain
+    // integer precision.
+    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
+    if (hi <= 0x1FFFFF) {
+        return String(TWO_PWR_32_DBL * hi + lo);
+    }
+    // What this code is doing is essentially converting the input number from
+    // base-2 to base-1e7, which allows us to represent the 64-bit range with
+    // only 3 (very large) digits. Those digits are then trivial to convert to
+    // a base-10 string.
+    // The magic numbers used here are -
+    // 2^24 = 16777216 = (1,6777216) in base-1e7.
+    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
+    // Split 32:32 representation into 16:24:24 representation so our
+    // intermediate digits don't overflow.
+    const low = lo & 0xFFFFFF;
+    const mid = ((lo >>> 24) | (hi << 8)) & 0xFFFFFF;
+    const high = (hi >> 16) & 0xFFFF;
+    // Assemble our three base-1e7 digits, ignoring carries. The maximum
+    // value in a digit at this step is representable as a 48-bit integer, which
+    // can be stored in a 64-bit floating point number.
+    let digitA = low + (mid * 6777216) + (high * 6710656);
+    let digitB = mid + (high * 8147497);
+    let digitC = (high * 2);
+    // Apply carries from A to B and from B to C.
+    const base = 10000000;
+    if (digitA >= base) {
+        digitB += Math.floor(digitA / base);
+        digitA %= base;
+    }
+    if (digitB >= base) {
+        digitC += Math.floor(digitB / base);
+        digitB %= base;
+    }
+    // If digitC is 0, then we should have returned in the trivial code path
+    // at the top for non-safe integers. Given this, we can assume both digitB
+    // and digitA need leading zeros.
+    return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) +
+        decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+    return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+    return { lo: lo | 0, hi: hi | 0 };
+}
+/**
+ * Returns two's compliment negation of input.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
+ */
+function negate(lowBits, highBits) {
+    highBits = ~highBits;
+    if (lowBits) {
+        lowBits = ~lowBits + 1;
+    }
+    else {
+        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
+        // adding 1 to that, results in 0x100000000, which leaves
+        // the low bits 0x0 and simply adds one to the high bits.
+        highBits += 1;
+    }
+    return newBits(lowBits, highBits);
+}
+/**
+ * Returns decimal representation of digit1e7 with leading zeros.
+ */
+const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+    const partial = String(digit1e7);
+    return "0000000".slice(partial.length) + partial;
+};
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export function varint32write(value, bytes) {
+    if (value >= 0) {
+        // write value as varint 32
+        while (value > 0x7f) {
+            bytes.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        bytes.push(value);
+    }
+    else {
+        for (let i = 0; i < 9; i++) {
+            bytes.push((value & 127) | 128);
+            value = value >> 7;
+        }
+        bytes.push(1);
+    }
+}
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export function varint32read() {
+    let b = this.buf[this.pos++];
+    let result = b & 0x7f;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 7;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 14;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 21;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    // Extract only last 4 bits
+    b = this.buf[this.pos++];
+    result |= (b & 0x0f) << 28;
+    for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+        b = this.buf[this.pos++];
+    if ((b & 0x80) != 0)
+        throw new Error("invalid varint");
+    this.assertBounds();
+    // Result can have 32 bits, convert it to unsigned
+    return result >>> 0;
+}

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

@@ -0,0 +1,42 @@
+export { proto3 } from "./proto3.js";
+export { proto2 } from "./proto2.js";
+export { protoDouble } from "./proto-double.js";
+export { protoInt64 } from "./proto-int64.js";
+export { protoBase64 } from "./proto-base64.js";
+export { protoDelimited } from "./proto-delimited.js";
+export { codegenInfo } from "./codegen-info.js";
+export { Message } from "./message.js";
+export type { AnyMessage, PartialMessage, PlainMessage } from "./message.js";
+export { isMessage } from "./is-message.js";
+export type { FieldInfo, OneofInfo } from "./field.js";
+export type { FieldList } from "./field-list.js";
+export { LongType, ScalarType } from "./scalar.js";
+export type { ScalarValue } from "./scalar.js";
+export type { MessageType } from "./message-type.js";
+export type { EnumType, EnumValueInfo } from "./enum.js";
+export type { Extension } from "./extension.js";
+export { getExtension, setExtension, hasExtension, clearExtension, } from "./extension-accessor.js";
+export type { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, } from "./service-type.js";
+export { MethodKind, MethodIdempotency } from "./service-type.js";
+export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
+export type { IBinaryReader, IBinaryWriter } from "./binary-encoding.js";
+export type { BinaryFormat, BinaryWriteOptions, BinaryReadOptions, } from "./binary-format.js";
+export type { JsonFormat, JsonObject, JsonValue, JsonReadOptions, JsonWriteOptions, JsonWriteStringOptions, } from "./json-format.js";
+export type { DescriptorSet, AnyDesc, DescFile, DescEnum, DescEnumValue, DescMessage, DescOneof, DescField, DescService, DescMethod, DescExtension, DescComments, } from "./descriptor-set.js";
+export { createDescriptorSet } from "./create-descriptor-set.js";
+export type { IMessageTypeRegistry, IExtensionRegistry, } from "./type-registry.js";
+export { createRegistry, createMutableRegistry } from "./create-registry.js";
+export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
+export { toPlainMessage } from "./to-plain-message.js";
+export * from "./google/protobuf/compiler/plugin_pb.js";
+export * from "./google/protobuf/api_pb.js";
+export * from "./google/protobuf/any_pb.js";
+export * from "./google/protobuf/descriptor_pb.js";
+export * from "./google/protobuf/duration_pb.js";
+export * from "./google/protobuf/empty_pb.js";
+export * from "./google/protobuf/field_mask_pb.js";
+export * from "./google/protobuf/source_context_pb.js";
+export * from "./google/protobuf/struct_pb.js";
+export * from "./google/protobuf/timestamp_pb.js";
+export * from "./google/protobuf/type_pb.js";
+export * from "./google/protobuf/wrappers_pb.js";

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

@@ -0,0 +1,43 @@
+// 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 { proto3 } from "./proto3.js";
+export { proto2 } from "./proto2.js";
+export { protoDouble } from "./proto-double.js";
+export { protoInt64 } from "./proto-int64.js";
+export { protoBase64 } from "./proto-base64.js";
+export { protoDelimited } from "./proto-delimited.js";
+export { codegenInfo } from "./codegen-info.js";
+export { Message } from "./message.js";
+export { isMessage } from "./is-message.js";
+export { LongType, ScalarType } from "./scalar.js";
+export { getExtension, setExtension, hasExtension, clearExtension, } from "./extension-accessor.js";
+export { MethodKind, MethodIdempotency } from "./service-type.js";
+export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
+export { createDescriptorSet } from "./create-descriptor-set.js";
+export { createRegistry, createMutableRegistry } from "./create-registry.js";
+export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
+export { toPlainMessage } from "./to-plain-message.js";
+// ideally, we would export these types with sub-path exports:
+export * from "./google/protobuf/compiler/plugin_pb.js";
+export * from "./google/protobuf/api_pb.js";
+export * from "./google/protobuf/any_pb.js";
+export * from "./google/protobuf/descriptor_pb.js";
+export * from "./google/protobuf/duration_pb.js";
+export * from "./google/protobuf/empty_pb.js";
+export * from "./google/protobuf/field_mask_pb.js";
+export * from "./google/protobuf/source_context_pb.js";
+export * from "./google/protobuf/struct_pb.js";
+export * from "./google/protobuf/timestamp_pb.js";
+export * from "./google/protobuf/type_pb.js";
+export * from "./google/protobuf/wrappers_pb.js";

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

@@ -0,0 +1,22 @@
+import type { MessageType } from "./message-type.js";
+import type { AnyMessage } from "./message.js";
+import { Message } from "./message.js";
+/**
+ * Check whether the given object is any subtype of Message or is a specific
+ * Message by passing the type.
+ *
+ * Just like `instanceof`, `isMessage` narrows the type. The advantage of
+ * `isMessage` is that it compares identity by the message type name, not by
+ * class identity. This makes it robust against the dual package hazard and
+ * similar situations, where the same message is duplicated.
+ *
+ * This function is _mostly_ equivalent to the `instanceof` operator. For
+ * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
+ * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
+ * `isMessage` should be preferred over `instanceof`.
+ *
+ * However, due to the fact that `isMessage` does not use class identity, there
+ * are subtle differences between this function and `instanceof`. Notably,
+ * calling `isMessage` on an explicit type of Message will return false.
+ */
+export declare function isMessage<T extends Message<T> = AnyMessage>(arg: unknown, type?: MessageType<T>): arg is T;

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

@@ -0,0 +1,48 @@
+// 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 { Message } from "./message.js";
+/**
+ * Check whether the given object is any subtype of Message or is a specific
+ * Message by passing the type.
+ *
+ * Just like `instanceof`, `isMessage` narrows the type. The advantage of
+ * `isMessage` is that it compares identity by the message type name, not by
+ * class identity. This makes it robust against the dual package hazard and
+ * similar situations, where the same message is duplicated.
+ *
+ * This function is _mostly_ equivalent to the `instanceof` operator. For
+ * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
+ * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
+ * `isMessage` should be preferred over `instanceof`.
+ *
+ * However, due to the fact that `isMessage` does not use class identity, there
+ * are subtle differences between this function and `instanceof`. Notably,
+ * calling `isMessage` on an explicit type of Message will return false.
+ */
+export function isMessage(arg, type) {
+    if (arg === null || typeof arg != "object") {
+        return false;
+    }
+    if (!Object.getOwnPropertyNames(Message.prototype).every((m) => m in arg && typeof arg[m] == "function")) {
+        return false;
+    }
+    const actualType = arg.getType();
+    if (actualType === null ||
+        typeof actualType != "function" ||
+        !("typeName" in actualType) ||
+        typeof actualType.typeName != "string") {
+        return false;
+    }
+    return type === undefined ? true : actualType.typeName == type.typeName;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/json-format.d.ts

@@ -0,0 +1,111 @@
+import type { Message } from "./message.js";
+import type { MessageType } from "./message-type.js";
+import type { ScalarType, LongType } from "./scalar.js";
+import type { IExtensionRegistry, IMessageTypeRegistry } from "./type-registry.js";
+/**
+ * JsonFormat is the contract for serializing messages to and from JSON.
+ * Implementations may be specific to a proto syntax, and can be reflection
+ * based, or delegate to speed optimized generated code.
+ */
+export interface JsonFormat {
+    /**
+     * Provide options for parsing JSON data.
+     */
+    makeReadOptions(options?: Partial<JsonReadOptions>): Readonly<JsonReadOptions>;
+    /**
+     * Provide options for serializing to JSON.
+     */
+    makeWriteOptions(options?: Partial<JsonWriteStringOptions>): Readonly<JsonWriteStringOptions>;
+    /**
+     * Parse a message from JSON.
+     */
+    readMessage<T extends Message<T>>(type: MessageType<T>, jsonValue: JsonValue, options: JsonReadOptions, message?: T): T;
+    /**
+     * Serialize a message to JSON.
+     */
+    writeMessage(message: Message, options: JsonWriteOptions): JsonValue;
+    /**
+     * Parse a single scalar value from JSON.
+     *
+     * This method may throw an error, but it may have a blank error message.
+     * Callers are expected to provide context.
+     */
+    readScalar(type: ScalarType, json: JsonValue, longType?: LongType): any;
+    /**
+     * Serialize a single scalar value to JSON.
+     */
+    writeScalar(type: ScalarType, value: any, emitDefaultValues: boolean): JsonValue | undefined;
+    /**
+     * Returns a short string representation of a JSON value, suitable for error messages.
+     */
+    debug(json: JsonValue): string;
+}
+/**
+ * Options for parsing JSON data.
+ */
+export interface JsonReadOptions {
+    /**
+     * Ignore unknown fields: Proto3 JSON parser should reject unknown fields
+     * by default. This option ignores unknown fields in parsing, as well as
+     * unrecognized enum string representations.
+     */
+    ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any` and extensions
+     * from JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry & Partial<IExtensionRegistry>;
+}
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteOptions {
+    /**
+     * Emit fields with default values: Fields with default values are omitted
+     * by default in proto3 JSON output. This option overrides this behavior
+     * and outputs fields with their default values.
+     */
+    emitDefaultValues: boolean;
+    /**
+     * Emit enum values as integers instead of strings: The name of an enum
+     * value is used by default in JSON output. An option may be provided to
+     * use the numeric value of the enum value instead.
+     */
+    enumAsInteger: boolean;
+    /**
+     * Use proto field name instead of lowerCamelCase name: By default proto3
+     * JSON printer should convert the field name to lowerCamelCase and use
+     * that as the JSON name. An implementation may provide an option to use
+     * proto field name as the JSON name instead. Proto3 JSON parsers are
+     * required to accept both the converted lowerCamelCase name and the proto
+     * field name.
+     */
+    useProtoFieldName: boolean;
+    /**
+     * This option is required to write `google.protobuf.Any` and extensions
+     * to JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry & Partial<IExtensionRegistry>;
+}
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteStringOptions extends JsonWriteOptions {
+    prettySpaces: number;
+}
+/**
+ * Represents any possible JSON value:
+ * - number
+ * - string
+ * - boolean
+ * - null
+ * - object (with any JSON value as property)
+ * - array (with any JSON value as element)
+ */
+export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[];
+/**
+ * Represents a JSON object.
+ */
+export type JsonObject = {
+    [k: string]: JsonValue;
+};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/json-format.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/dist/esm/message-type.d.ts

@@ -0,0 +1,51 @@
+import type { FieldList } from "./field-list.js";
+import type { ProtoRuntime } from "./private/proto-runtime.js";
+import type { JsonReadOptions, JsonValue } from "./json-format.js";
+import type { BinaryReadOptions } from "./binary-format.js";
+import type { AnyMessage, Message, PartialMessage, PlainMessage } from "./message.js";
+import type { FieldWrapper } from "./private/field-wrapper.js";
+/**
+ * MessageType represents a protobuf message. It provides:
+ * - a constructor that produces an instance of the message
+ * - metadata for reflection-based operations
+ * - common functionality like serialization
+ */
+export interface MessageType<T extends Message<T> = AnyMessage> {
+    /**
+     * Create a new instance of this type.
+     */
+    new (data?: PartialMessage<T>): T;
+    /**
+     * The fully qualified name of the message.
+     */
+    readonly typeName: string;
+    /**
+     * Field metadata.
+     */
+    readonly fields: FieldList;
+    /**
+     * Provides serialization and other functionality.
+     */
+    readonly runtime: ProtoRuntime;
+    /**
+     * When used as a field, unwrap this message to a simple value.
+     */
+    readonly fieldWrapper?: FieldWrapper<T>;
+    /**
+     * Parse serialized binary data.
+     */
+    fromBinary(data: Uint8Array, options?: Partial<BinaryReadOptions>): T;
+    /**
+     * Parse a JSON object.
+     */
+    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Parse a JSON string.
+     */
+    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Returns true if the given arguments have equal field values, recursively.
+     * Will also return true if both messages are `undefined` or `null`.
+     */
+    equals(a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/message-type.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 {};