@canton-network/core-ledger-proto 0.10.0 → 0.11.0

package/dist/cjs/_proto/google/protobuf/descriptor.cjs

@@ -0,0 +1,3482 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var descriptor_exports = {};
+__export(descriptor_exports, {
+  DescriptorProto: () => DescriptorProto,
+  DescriptorProto_ExtensionRange: () => DescriptorProto_ExtensionRange,
+  DescriptorProto_ReservedRange: () => DescriptorProto_ReservedRange,
+  EnumDescriptorProto: () => EnumDescriptorProto,
+  EnumDescriptorProto_EnumReservedRange: () => EnumDescriptorProto_EnumReservedRange,
+  EnumOptions: () => EnumOptions,
+  EnumValueDescriptorProto: () => EnumValueDescriptorProto,
+  EnumValueOptions: () => EnumValueOptions,
+  ExtensionRangeOptions: () => ExtensionRangeOptions,
+  FieldDescriptorProto: () => FieldDescriptorProto,
+  FieldDescriptorProto_Label: () => FieldDescriptorProto_Label,
+  FieldDescriptorProto_Type: () => FieldDescriptorProto_Type,
+  FieldOptions: () => FieldOptions,
+  FieldOptions_CType: () => FieldOptions_CType,
+  FieldOptions_JSType: () => FieldOptions_JSType,
+  FileDescriptorProto: () => FileDescriptorProto,
+  FileDescriptorSet: () => FileDescriptorSet,
+  FileOptions: () => FileOptions,
+  FileOptions_OptimizeMode: () => FileOptions_OptimizeMode,
+  GeneratedCodeInfo: () => GeneratedCodeInfo,
+  GeneratedCodeInfo_Annotation: () => GeneratedCodeInfo_Annotation,
+  MessageOptions: () => MessageOptions,
+  MethodDescriptorProto: () => MethodDescriptorProto,
+  MethodOptions: () => MethodOptions,
+  MethodOptions_IdempotencyLevel: () => MethodOptions_IdempotencyLevel,
+  OneofDescriptorProto: () => OneofDescriptorProto,
+  OneofOptions: () => OneofOptions,
+  ServiceDescriptorProto: () => ServiceDescriptorProto,
+  ServiceOptions: () => ServiceOptions,
+  SourceCodeInfo: () => SourceCodeInfo,
+  SourceCodeInfo_Location: () => SourceCodeInfo_Location,
+  UninterpretedOption: () => UninterpretedOption,
+  UninterpretedOption_NamePart: () => UninterpretedOption_NamePart
+});
+module.exports = __toCommonJS(descriptor_exports);
+var import_runtime = require("@protobuf-ts/runtime");
+var import_runtime2 = require("@protobuf-ts/runtime");
+var import_runtime3 = require("@protobuf-ts/runtime");
+var import_runtime4 = require("@protobuf-ts/runtime");
+var FieldDescriptorProto_Type = /* @__PURE__ */ ((FieldDescriptorProto_Type2) => {
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["DOUBLE"] = 1] = "DOUBLE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FLOAT"] = 2] = "FLOAT";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT64"] = 3] = "INT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT64"] = 4] = "UINT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT32"] = 5] = "INT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED64"] = 6] = "FIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED32"] = 7] = "FIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BOOL"] = 8] = "BOOL";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["STRING"] = 9] = "STRING";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["GROUP"] = 10] = "GROUP";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["MESSAGE"] = 11] = "MESSAGE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BYTES"] = 12] = "BYTES";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT32"] = 13] = "UINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["ENUM"] = 14] = "ENUM";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED32"] = 15] = "SFIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED64"] = 16] = "SFIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT32"] = 17] = "SINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT64"] = 18] = "SINT64";
+  return FieldDescriptorProto_Type2;
+})(FieldDescriptorProto_Type || {});
+var FieldDescriptorProto_Label = /* @__PURE__ */ ((FieldDescriptorProto_Label2) => {
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["OPTIONAL"] = 1] = "OPTIONAL";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REQUIRED"] = 2] = "REQUIRED";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REPEATED"] = 3] = "REPEATED";
+  return FieldDescriptorProto_Label2;
+})(FieldDescriptorProto_Label || {});
+var FileOptions_OptimizeMode = /* @__PURE__ */ ((FileOptions_OptimizeMode2) => {
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["UNSPECIFIED$"] = 0] = "UNSPECIFIED$";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["SPEED"] = 1] = "SPEED";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["CODE_SIZE"] = 2] = "CODE_SIZE";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
+  return FileOptions_OptimizeMode2;
+})(FileOptions_OptimizeMode || {});
+var FieldOptions_CType = /* @__PURE__ */ ((FieldOptions_CType2) => {
+  FieldOptions_CType2[FieldOptions_CType2["STRING"] = 0] = "STRING";
+  FieldOptions_CType2[FieldOptions_CType2["CORD"] = 1] = "CORD";
+  FieldOptions_CType2[FieldOptions_CType2["STRING_PIECE"] = 2] = "STRING_PIECE";
+  return FieldOptions_CType2;
+})(FieldOptions_CType || {});
+var FieldOptions_JSType = /* @__PURE__ */ ((FieldOptions_JSType2) => {
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NORMAL"] = 0] = "JS_NORMAL";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_STRING"] = 1] = "JS_STRING";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NUMBER"] = 2] = "JS_NUMBER";
+  return FieldOptions_JSType2;
+})(FieldOptions_JSType || {});
+var MethodOptions_IdempotencyLevel = /* @__PURE__ */ ((MethodOptions_IdempotencyLevel2) => {
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENT"] = 2] = "IDEMPOTENT";
+  return MethodOptions_IdempotencyLevel2;
+})(MethodOptions_IdempotencyLevel || {});
+class FileDescriptorSet$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.FileDescriptorSet", [
+      {
+        no: 1,
+        name: "file",
+        kind: "message",
+        repeat: 2,
+        T: () => FileDescriptorProto
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.file = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.FileDescriptorProto file */
+        1:
+          message.file.push(
+            FileDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.file.length; i++)
+      FileDescriptorProto.internalBinaryWrite(
+        message.file[i],
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const FileDescriptorSet = new FileDescriptorSet$Type();
+class FileDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.FileDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "package",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "dependency",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      },
+      {
+        no: 10,
+        name: "public_dependency",
+        kind: "scalar",
+        repeat: 2,
+        T: 5
+      },
+      {
+        no: 11,
+        name: "weak_dependency",
+        kind: "scalar",
+        repeat: 2,
+        T: 5
+      },
+      {
+        no: 4,
+        name: "message_type",
+        kind: "message",
+        repeat: 2,
+        T: () => DescriptorProto
+      },
+      {
+        no: 5,
+        name: "enum_type",
+        kind: "message",
+        repeat: 2,
+        T: () => EnumDescriptorProto
+      },
+      {
+        no: 6,
+        name: "service",
+        kind: "message",
+        repeat: 2,
+        T: () => ServiceDescriptorProto
+      },
+      {
+        no: 7,
+        name: "extension",
+        kind: "message",
+        repeat: 2,
+        T: () => FieldDescriptorProto
+      },
+      { no: 8, name: "options", kind: "message", T: () => FileOptions },
+      {
+        no: 9,
+        name: "source_code_info",
+        kind: "message",
+        T: () => SourceCodeInfo
+      },
+      {
+        no: 12,
+        name: "syntax",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.dependency = [];
+    message.publicDependency = [];
+    message.weakDependency = [];
+    message.messageType = [];
+    message.enumType = [];
+    message.service = [];
+    message.extension = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional string package */
+        2:
+          message.package = reader.string();
+          break;
+        case /* repeated string dependency */
+        3:
+          message.dependency.push(reader.string());
+          break;
+        case /* repeated int32 public_dependency */
+        10:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.publicDependency.push(reader.int32());
+          else message.publicDependency.push(reader.int32());
+          break;
+        case /* repeated int32 weak_dependency */
+        11:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.weakDependency.push(reader.int32());
+          else message.weakDependency.push(reader.int32());
+          break;
+        case /* repeated google.protobuf.DescriptorProto message_type */
+        4:
+          message.messageType.push(
+            DescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.EnumDescriptorProto enum_type */
+        5:
+          message.enumType.push(
+            EnumDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.ServiceDescriptorProto service */
+        6:
+          message.service.push(
+            ServiceDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.FieldDescriptorProto extension */
+        7:
+          message.extension.push(
+            FieldDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional google.protobuf.FileOptions options */
+        8:
+          message.options = FileOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        case /* optional google.protobuf.SourceCodeInfo source_code_info */
+        9:
+          message.sourceCodeInfo = SourceCodeInfo.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.sourceCodeInfo
+          );
+          break;
+        case /* optional string syntax */
+        12:
+          message.syntax = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.package !== void 0)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.package);
+    for (let i = 0; i < message.dependency.length; i++)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.dependency[i]);
+    for (let i = 0; i < message.messageType.length; i++)
+      DescriptorProto.internalBinaryWrite(
+        message.messageType[i],
+        writer.tag(4, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.enumType.length; i++)
+      EnumDescriptorProto.internalBinaryWrite(
+        message.enumType[i],
+        writer.tag(5, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.service.length; i++)
+      ServiceDescriptorProto.internalBinaryWrite(
+        message.service[i],
+        writer.tag(6, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.extension.length; i++)
+      FieldDescriptorProto.internalBinaryWrite(
+        message.extension[i],
+        writer.tag(7, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.options)
+      FileOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(8, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.sourceCodeInfo)
+      SourceCodeInfo.internalBinaryWrite(
+        message.sourceCodeInfo,
+        writer.tag(9, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.publicDependency.length; i++)
+      writer.tag(10, import_runtime.WireType.Varint).int32(message.publicDependency[i]);
+    for (let i = 0; i < message.weakDependency.length; i++)
+      writer.tag(11, import_runtime.WireType.Varint).int32(message.weakDependency[i]);
+    if (message.syntax !== void 0)
+      writer.tag(12, import_runtime.WireType.LengthDelimited).string(message.syntax);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const FileDescriptorProto = new FileDescriptorProto$Type();
+class DescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.DescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "field",
+        kind: "message",
+        repeat: 2,
+        T: () => FieldDescriptorProto
+      },
+      {
+        no: 6,
+        name: "extension",
+        kind: "message",
+        repeat: 2,
+        T: () => FieldDescriptorProto
+      },
+      {
+        no: 3,
+        name: "nested_type",
+        kind: "message",
+        repeat: 2,
+        T: () => DescriptorProto
+      },
+      {
+        no: 4,
+        name: "enum_type",
+        kind: "message",
+        repeat: 2,
+        T: () => EnumDescriptorProto
+      },
+      {
+        no: 5,
+        name: "extension_range",
+        kind: "message",
+        repeat: 2,
+        T: () => DescriptorProto_ExtensionRange
+      },
+      {
+        no: 8,
+        name: "oneof_decl",
+        kind: "message",
+        repeat: 2,
+        T: () => OneofDescriptorProto
+      },
+      {
+        no: 7,
+        name: "options",
+        kind: "message",
+        T: () => MessageOptions
+      },
+      {
+        no: 9,
+        name: "reserved_range",
+        kind: "message",
+        repeat: 2,
+        T: () => DescriptorProto_ReservedRange
+      },
+      {
+        no: 10,
+        name: "reserved_name",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.field = [];
+    message.extension = [];
+    message.nestedType = [];
+    message.enumType = [];
+    message.extensionRange = [];
+    message.oneofDecl = [];
+    message.reservedRange = [];
+    message.reservedName = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* repeated google.protobuf.FieldDescriptorProto field */
+        2:
+          message.field.push(
+            FieldDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.FieldDescriptorProto extension */
+        6:
+          message.extension.push(
+            FieldDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.DescriptorProto nested_type */
+        3:
+          message.nestedType.push(
+            DescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.EnumDescriptorProto enum_type */
+        4:
+          message.enumType.push(
+            EnumDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.DescriptorProto.ExtensionRange extension_range */
+        5:
+          message.extensionRange.push(
+            DescriptorProto_ExtensionRange.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated google.protobuf.OneofDescriptorProto oneof_decl */
+        8:
+          message.oneofDecl.push(
+            OneofDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional google.protobuf.MessageOptions options */
+        7:
+          message.options = MessageOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        case /* repeated google.protobuf.DescriptorProto.ReservedRange reserved_range */
+        9:
+          message.reservedRange.push(
+            DescriptorProto_ReservedRange.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated string reserved_name */
+        10:
+          message.reservedName.push(reader.string());
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    for (let i = 0; i < message.field.length; i++)
+      FieldDescriptorProto.internalBinaryWrite(
+        message.field[i],
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.nestedType.length; i++)
+      DescriptorProto.internalBinaryWrite(
+        message.nestedType[i],
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.enumType.length; i++)
+      EnumDescriptorProto.internalBinaryWrite(
+        message.enumType[i],
+        writer.tag(4, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.extensionRange.length; i++)
+      DescriptorProto_ExtensionRange.internalBinaryWrite(
+        message.extensionRange[i],
+        writer.tag(5, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.extension.length; i++)
+      FieldDescriptorProto.internalBinaryWrite(
+        message.extension[i],
+        writer.tag(6, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.options)
+      MessageOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(7, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.oneofDecl.length; i++)
+      OneofDescriptorProto.internalBinaryWrite(
+        message.oneofDecl[i],
+        writer.tag(8, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.reservedRange.length; i++)
+      DescriptorProto_ReservedRange.internalBinaryWrite(
+        message.reservedRange[i],
+        writer.tag(9, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.reservedName.length; i++)
+      writer.tag(10, import_runtime.WireType.LengthDelimited).string(message.reservedName[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const DescriptorProto = new DescriptorProto$Type();
+class DescriptorProto_ExtensionRange$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.DescriptorProto.ExtensionRange", [
+      {
+        no: 1,
+        name: "start",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 2,
+        name: "end",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 3,
+        name: "options",
+        kind: "message",
+        T: () => ExtensionRangeOptions
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional int32 start */
+        1:
+          message.start = reader.int32();
+          break;
+        case /* optional int32 end */
+        2:
+          message.end = reader.int32();
+          break;
+        case /* optional google.protobuf.ExtensionRangeOptions options */
+        3:
+          message.options = ExtensionRangeOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.start !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.start);
+    if (message.end !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.end);
+    if (message.options)
+      ExtensionRangeOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const DescriptorProto_ExtensionRange = new DescriptorProto_ExtensionRange$Type();
+class DescriptorProto_ReservedRange$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.DescriptorProto.ReservedRange", [
+      {
+        no: 1,
+        name: "start",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 2,
+        name: "end",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional int32 start */
+        1:
+          message.start = reader.int32();
+          break;
+        case /* optional int32 end */
+        2:
+          message.end = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.start !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.start);
+    if (message.end !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.end);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const DescriptorProto_ReservedRange = new DescriptorProto_ReservedRange$Type();
+class ExtensionRangeOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.ExtensionRangeOptions", [
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ExtensionRangeOptions = new ExtensionRangeOptions$Type();
+class FieldDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.FieldDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "number",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 4,
+        name: "label",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.FieldDescriptorProto.Label",
+          FieldDescriptorProto_Label,
+          "LABEL_"
+        ]
+      },
+      {
+        no: 5,
+        name: "type",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.FieldDescriptorProto.Type",
+          FieldDescriptorProto_Type,
+          "TYPE_"
+        ]
+      },
+      {
+        no: 6,
+        name: "type_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "extendee",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 7,
+        name: "default_value",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 9,
+        name: "oneof_index",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 10,
+        name: "json_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      { no: 8, name: "options", kind: "message", T: () => FieldOptions },
+      {
+        no: 17,
+        name: "proto3_optional",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional int32 number */
+        3:
+          message.number = reader.int32();
+          break;
+        case /* optional google.protobuf.FieldDescriptorProto.Label label */
+        4:
+          message.label = reader.int32();
+          break;
+        case /* optional google.protobuf.FieldDescriptorProto.Type type */
+        5:
+          message.type = reader.int32();
+          break;
+        case /* optional string type_name */
+        6:
+          message.typeName = reader.string();
+          break;
+        case /* optional string extendee */
+        2:
+          message.extendee = reader.string();
+          break;
+        case /* optional string default_value */
+        7:
+          message.defaultValue = reader.string();
+          break;
+        case /* optional int32 oneof_index */
+        9:
+          message.oneofIndex = reader.int32();
+          break;
+        case /* optional string json_name */
+        10:
+          message.jsonName = reader.string();
+          break;
+        case /* optional google.protobuf.FieldOptions options */
+        8:
+          message.options = FieldOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        case /* optional bool proto3_optional */
+        17:
+          message.proto3Optional = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.extendee !== void 0)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.extendee);
+    if (message.number !== void 0)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.number);
+    if (message.label !== void 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.label);
+    if (message.type !== void 0)
+      writer.tag(5, import_runtime.WireType.Varint).int32(message.type);
+    if (message.typeName !== void 0)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.typeName);
+    if (message.defaultValue !== void 0)
+      writer.tag(7, import_runtime.WireType.LengthDelimited).string(message.defaultValue);
+    if (message.options)
+      FieldOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(8, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.oneofIndex !== void 0)
+      writer.tag(9, import_runtime.WireType.Varint).int32(message.oneofIndex);
+    if (message.jsonName !== void 0)
+      writer.tag(10, import_runtime.WireType.LengthDelimited).string(message.jsonName);
+    if (message.proto3Optional !== void 0)
+      writer.tag(17, import_runtime.WireType.Varint).bool(message.proto3Optional);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const FieldDescriptorProto = new FieldDescriptorProto$Type();
+class OneofDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.OneofDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      { no: 2, name: "options", kind: "message", T: () => OneofOptions }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional google.protobuf.OneofOptions options */
+        2:
+          message.options = OneofOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.options)
+      OneofOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const OneofDescriptorProto = new OneofDescriptorProto$Type();
+class EnumDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.EnumDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "value",
+        kind: "message",
+        repeat: 2,
+        T: () => EnumValueDescriptorProto
+      },
+      { no: 3, name: "options", kind: "message", T: () => EnumOptions },
+      {
+        no: 4,
+        name: "reserved_range",
+        kind: "message",
+        repeat: 2,
+        T: () => EnumDescriptorProto_EnumReservedRange
+      },
+      {
+        no: 5,
+        name: "reserved_name",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.value = [];
+    message.reservedRange = [];
+    message.reservedName = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* repeated google.protobuf.EnumValueDescriptorProto value */
+        2:
+          message.value.push(
+            EnumValueDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional google.protobuf.EnumOptions options */
+        3:
+          message.options = EnumOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        case /* repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range */
+        4:
+          message.reservedRange.push(
+            EnumDescriptorProto_EnumReservedRange.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* repeated string reserved_name */
+        5:
+          message.reservedName.push(reader.string());
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    for (let i = 0; i < message.value.length; i++)
+      EnumValueDescriptorProto.internalBinaryWrite(
+        message.value[i],
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.options)
+      EnumOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.reservedRange.length; i++)
+      EnumDescriptorProto_EnumReservedRange.internalBinaryWrite(
+        message.reservedRange[i],
+        writer.tag(4, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.reservedName.length; i++)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.reservedName[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const EnumDescriptorProto = new EnumDescriptorProto$Type();
+class EnumDescriptorProto_EnumReservedRange$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.EnumDescriptorProto.EnumReservedRange", [
+      {
+        no: 1,
+        name: "start",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 2,
+        name: "end",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional int32 start */
+        1:
+          message.start = reader.int32();
+          break;
+        case /* optional int32 end */
+        2:
+          message.end = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.start !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.start);
+    if (message.end !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.end);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const EnumDescriptorProto_EnumReservedRange = new EnumDescriptorProto_EnumReservedRange$Type();
+class EnumValueDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.EnumValueDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "number",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 3,
+        name: "options",
+        kind: "message",
+        T: () => EnumValueOptions
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional int32 number */
+        2:
+          message.number = reader.int32();
+          break;
+        case /* optional google.protobuf.EnumValueOptions options */
+        3:
+          message.options = EnumValueOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.number !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.number);
+    if (message.options)
+      EnumValueOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const EnumValueDescriptorProto = new EnumValueDescriptorProto$Type();
+class ServiceDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.ServiceDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "method",
+        kind: "message",
+        repeat: 2,
+        T: () => MethodDescriptorProto
+      },
+      {
+        no: 3,
+        name: "options",
+        kind: "message",
+        T: () => ServiceOptions
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.method = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* repeated google.protobuf.MethodDescriptorProto method */
+        2:
+          message.method.push(
+            MethodDescriptorProto.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional google.protobuf.ServiceOptions options */
+        3:
+          message.options = ServiceOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    for (let i = 0; i < message.method.length; i++)
+      MethodDescriptorProto.internalBinaryWrite(
+        message.method[i],
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.options)
+      ServiceOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ServiceDescriptorProto = new ServiceDescriptorProto$Type();
+class MethodDescriptorProto$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.MethodDescriptorProto", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "input_type",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "output_type",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      { no: 4, name: "options", kind: "message", T: () => MethodOptions },
+      {
+        no: 5,
+        name: "client_streaming",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 6,
+        name: "server_streaming",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional string input_type */
+        2:
+          message.inputType = reader.string();
+          break;
+        case /* optional string output_type */
+        3:
+          message.outputType = reader.string();
+          break;
+        case /* optional google.protobuf.MethodOptions options */
+        4:
+          message.options = MethodOptions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.options
+          );
+          break;
+        case /* optional bool client_streaming = 5 [default = false] */
+        5:
+          message.clientStreaming = reader.bool();
+          break;
+        case /* optional bool server_streaming = 6 [default = false] */
+        6:
+          message.serverStreaming = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.inputType !== void 0)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.inputType);
+    if (message.outputType !== void 0)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.outputType);
+    if (message.options)
+      MethodOptions.internalBinaryWrite(
+        message.options,
+        writer.tag(4, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.clientStreaming !== void 0)
+      writer.tag(5, import_runtime.WireType.Varint).bool(message.clientStreaming);
+    if (message.serverStreaming !== void 0)
+      writer.tag(6, import_runtime.WireType.Varint).bool(message.serverStreaming);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const MethodDescriptorProto = new MethodDescriptorProto$Type();
+class FileOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.FileOptions", [
+      {
+        no: 1,
+        name: "java_package",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 8,
+        name: "java_outer_classname",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 10,
+        name: "java_multiple_files",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 20,
+        name: "java_generate_equals_and_hash",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 27,
+        name: "java_string_check_utf8",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 9,
+        name: "optimize_for",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.FileOptions.OptimizeMode",
+          FileOptions_OptimizeMode
+        ]
+      },
+      {
+        no: 11,
+        name: "go_package",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 16,
+        name: "cc_generic_services",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 17,
+        name: "java_generic_services",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 18,
+        name: "py_generic_services",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 42,
+        name: "php_generic_services",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 23,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 31,
+        name: "cc_enable_arenas",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 36,
+        name: "objc_class_prefix",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 37,
+        name: "csharp_namespace",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 39,
+        name: "swift_prefix",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 40,
+        name: "php_class_prefix",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 41,
+        name: "php_namespace",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 44,
+        name: "php_metadata_namespace",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 45,
+        name: "ruby_package",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string java_package */
+        1:
+          message.javaPackage = reader.string();
+          break;
+        case /* optional string java_outer_classname */
+        8:
+          message.javaOuterClassname = reader.string();
+          break;
+        case /* optional bool java_multiple_files = 10 [default = false] */
+        10:
+          message.javaMultipleFiles = reader.bool();
+          break;
+        case /* optional bool java_generate_equals_and_hash = 20 [deprecated = true] */
+        20:
+          message.javaGenerateEqualsAndHash = reader.bool();
+          break;
+        case /* optional bool java_string_check_utf8 = 27 [default = false] */
+        27:
+          message.javaStringCheckUtf8 = reader.bool();
+          break;
+        case /* optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED] */
+        9:
+          message.optimizeFor = reader.int32();
+          break;
+        case /* optional string go_package */
+        11:
+          message.goPackage = reader.string();
+          break;
+        case /* optional bool cc_generic_services = 16 [default = false] */
+        16:
+          message.ccGenericServices = reader.bool();
+          break;
+        case /* optional bool java_generic_services = 17 [default = false] */
+        17:
+          message.javaGenericServices = reader.bool();
+          break;
+        case /* optional bool py_generic_services = 18 [default = false] */
+        18:
+          message.pyGenericServices = reader.bool();
+          break;
+        case /* optional bool php_generic_services = 42 [default = false] */
+        42:
+          message.phpGenericServices = reader.bool();
+          break;
+        case /* optional bool deprecated = 23 [default = false] */
+        23:
+          message.deprecated = reader.bool();
+          break;
+        case /* optional bool cc_enable_arenas = 31 [default = true] */
+        31:
+          message.ccEnableArenas = reader.bool();
+          break;
+        case /* optional string objc_class_prefix */
+        36:
+          message.objcClassPrefix = reader.string();
+          break;
+        case /* optional string csharp_namespace */
+        37:
+          message.csharpNamespace = reader.string();
+          break;
+        case /* optional string swift_prefix */
+        39:
+          message.swiftPrefix = reader.string();
+          break;
+        case /* optional string php_class_prefix */
+        40:
+          message.phpClassPrefix = reader.string();
+          break;
+        case /* optional string php_namespace */
+        41:
+          message.phpNamespace = reader.string();
+          break;
+        case /* optional string php_metadata_namespace */
+        44:
+          message.phpMetadataNamespace = reader.string();
+          break;
+        case /* optional string ruby_package */
+        45:
+          message.rubyPackage = reader.string();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.javaPackage !== void 0)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.javaPackage);
+    if (message.javaOuterClassname !== void 0)
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.javaOuterClassname);
+    if (message.optimizeFor !== void 0)
+      writer.tag(9, import_runtime.WireType.Varint).int32(message.optimizeFor);
+    if (message.javaMultipleFiles !== void 0)
+      writer.tag(10, import_runtime.WireType.Varint).bool(message.javaMultipleFiles);
+    if (message.goPackage !== void 0)
+      writer.tag(11, import_runtime.WireType.LengthDelimited).string(message.goPackage);
+    if (message.ccGenericServices !== void 0)
+      writer.tag(16, import_runtime.WireType.Varint).bool(message.ccGenericServices);
+    if (message.javaGenericServices !== void 0)
+      writer.tag(17, import_runtime.WireType.Varint).bool(message.javaGenericServices);
+    if (message.pyGenericServices !== void 0)
+      writer.tag(18, import_runtime.WireType.Varint).bool(message.pyGenericServices);
+    if (message.javaGenerateEqualsAndHash !== void 0)
+      writer.tag(20, import_runtime.WireType.Varint).bool(message.javaGenerateEqualsAndHash);
+    if (message.deprecated !== void 0)
+      writer.tag(23, import_runtime.WireType.Varint).bool(message.deprecated);
+    if (message.javaStringCheckUtf8 !== void 0)
+      writer.tag(27, import_runtime.WireType.Varint).bool(message.javaStringCheckUtf8);
+    if (message.ccEnableArenas !== void 0)
+      writer.tag(31, import_runtime.WireType.Varint).bool(message.ccEnableArenas);
+    if (message.objcClassPrefix !== void 0)
+      writer.tag(36, import_runtime.WireType.LengthDelimited).string(message.objcClassPrefix);
+    if (message.csharpNamespace !== void 0)
+      writer.tag(37, import_runtime.WireType.LengthDelimited).string(message.csharpNamespace);
+    if (message.swiftPrefix !== void 0)
+      writer.tag(39, import_runtime.WireType.LengthDelimited).string(message.swiftPrefix);
+    if (message.phpClassPrefix !== void 0)
+      writer.tag(40, import_runtime.WireType.LengthDelimited).string(message.phpClassPrefix);
+    if (message.phpNamespace !== void 0)
+      writer.tag(41, import_runtime.WireType.LengthDelimited).string(message.phpNamespace);
+    if (message.phpGenericServices !== void 0)
+      writer.tag(42, import_runtime.WireType.Varint).bool(message.phpGenericServices);
+    if (message.phpMetadataNamespace !== void 0)
+      writer.tag(44, import_runtime.WireType.LengthDelimited).string(message.phpMetadataNamespace);
+    if (message.rubyPackage !== void 0)
+      writer.tag(45, import_runtime.WireType.LengthDelimited).string(message.rubyPackage);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const FileOptions = new FileOptions$Type();
+class MessageOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.MessageOptions", [
+      {
+        no: 1,
+        name: "message_set_wire_format",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 2,
+        name: "no_standard_descriptor_accessor",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 3,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 7,
+        name: "map_entry",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional bool message_set_wire_format = 1 [default = false] */
+        1:
+          message.messageSetWireFormat = reader.bool();
+          break;
+        case /* optional bool no_standard_descriptor_accessor = 2 [default = false] */
+        2:
+          message.noStandardDescriptorAccessor = reader.bool();
+          break;
+        case /* optional bool deprecated = 3 [default = false] */
+        3:
+          message.deprecated = reader.bool();
+          break;
+        case /* optional bool map_entry */
+        7:
+          message.mapEntry = reader.bool();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.messageSetWireFormat !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.messageSetWireFormat);
+    if (message.noStandardDescriptorAccessor !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.noStandardDescriptorAccessor);
+    if (message.deprecated !== void 0)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.deprecated);
+    if (message.mapEntry !== void 0)
+      writer.tag(7, import_runtime.WireType.Varint).bool(message.mapEntry);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const MessageOptions = new MessageOptions$Type();
+class FieldOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.FieldOptions", [
+      {
+        no: 1,
+        name: "ctype",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.FieldOptions.CType",
+          FieldOptions_CType
+        ]
+      },
+      {
+        no: 2,
+        name: "packed",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 6,
+        name: "jstype",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.FieldOptions.JSType",
+          FieldOptions_JSType
+        ]
+      },
+      {
+        no: 5,
+        name: "lazy",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 3,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 10,
+        name: "weak",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING] */
+        1:
+          message.ctype = reader.int32();
+          break;
+        case /* optional bool packed */
+        2:
+          message.packed = reader.bool();
+          break;
+        case /* optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL] */
+        6:
+          message.jstype = reader.int32();
+          break;
+        case /* optional bool lazy = 5 [default = false] */
+        5:
+          message.lazy = reader.bool();
+          break;
+        case /* optional bool deprecated = 3 [default = false] */
+        3:
+          message.deprecated = reader.bool();
+          break;
+        case /* optional bool weak = 10 [default = false] */
+        10:
+          message.weak = reader.bool();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.ctype !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.ctype);
+    if (message.packed !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.packed);
+    if (message.deprecated !== void 0)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.deprecated);
+    if (message.lazy !== void 0)
+      writer.tag(5, import_runtime.WireType.Varint).bool(message.lazy);
+    if (message.jstype !== void 0)
+      writer.tag(6, import_runtime.WireType.Varint).int32(message.jstype);
+    if (message.weak !== void 0)
+      writer.tag(10, import_runtime.WireType.Varint).bool(message.weak);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const FieldOptions = new FieldOptions$Type();
+class OneofOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.OneofOptions", [
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const OneofOptions = new OneofOptions$Type();
+class EnumOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.EnumOptions", [
+      {
+        no: 2,
+        name: "allow_alias",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 3,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional bool allow_alias */
+        2:
+          message.allowAlias = reader.bool();
+          break;
+        case /* optional bool deprecated = 3 [default = false] */
+        3:
+          message.deprecated = reader.bool();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.allowAlias !== void 0)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.allowAlias);
+    if (message.deprecated !== void 0)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.deprecated);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const EnumOptions = new EnumOptions$Type();
+class EnumValueOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.EnumValueOptions", [
+      {
+        no: 1,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional bool deprecated = 1 [default = false] */
+        1:
+          message.deprecated = reader.bool();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.deprecated !== void 0)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.deprecated);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const EnumValueOptions = new EnumValueOptions$Type();
+class ServiceOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.ServiceOptions", [
+      {
+        no: 33,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional bool deprecated = 33 [default = false] */
+        33:
+          message.deprecated = reader.bool();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.deprecated !== void 0)
+      writer.tag(33, import_runtime.WireType.Varint).bool(message.deprecated);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ServiceOptions = new ServiceOptions$Type();
+class MethodOptions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.MethodOptions", [
+      {
+        no: 33,
+        name: "deprecated",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 34,
+        name: "idempotency_level",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "google.protobuf.MethodOptions.IdempotencyLevel",
+          MethodOptions_IdempotencyLevel
+        ]
+      },
+      {
+        no: 999,
+        name: "uninterpreted_option",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uninterpretedOption = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional bool deprecated = 33 [default = false] */
+        33:
+          message.deprecated = reader.bool();
+          break;
+        case /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN] */
+        34:
+          message.idempotencyLevel = reader.int32();
+          break;
+        case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */
+        999:
+          message.uninterpretedOption.push(
+            UninterpretedOption.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.deprecated !== void 0)
+      writer.tag(33, import_runtime.WireType.Varint).bool(message.deprecated);
+    if (message.idempotencyLevel !== void 0)
+      writer.tag(34, import_runtime.WireType.Varint).int32(message.idempotencyLevel);
+    for (let i = 0; i < message.uninterpretedOption.length; i++)
+      UninterpretedOption.internalBinaryWrite(
+        message.uninterpretedOption[i],
+        writer.tag(999, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const MethodOptions = new MethodOptions$Type();
+class UninterpretedOption$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.UninterpretedOption", [
+      {
+        no: 2,
+        name: "name",
+        kind: "message",
+        repeat: 2,
+        T: () => UninterpretedOption_NamePart
+      },
+      {
+        no: 3,
+        name: "identifier_value",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 4,
+        name: "positive_int_value",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+      },
+      {
+        no: 5,
+        name: "negative_int_value",
+        kind: "scalar",
+        opt: true,
+        T: 3,
+        L: 0
+      },
+      {
+        no: 6,
+        name: "double_value",
+        kind: "scalar",
+        opt: true,
+        T: 1
+      },
+      {
+        no: 7,
+        name: "string_value",
+        kind: "scalar",
+        opt: true,
+        T: 12
+      },
+      {
+        no: 8,
+        name: "aggregate_value",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.UninterpretedOption.NamePart name */
+        2:
+          message.name.push(
+            UninterpretedOption_NamePart.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional string identifier_value */
+        3:
+          message.identifierValue = reader.string();
+          break;
+        case /* optional uint64 positive_int_value */
+        4:
+          message.positiveIntValue = reader.uint64().toBigInt();
+          break;
+        case /* optional int64 negative_int_value */
+        5:
+          message.negativeIntValue = reader.int64().toBigInt();
+          break;
+        case /* optional double double_value */
+        6:
+          message.doubleValue = reader.double();
+          break;
+        case /* optional bytes string_value */
+        7:
+          message.stringValue = reader.bytes();
+          break;
+        case /* optional string aggregate_value */
+        8:
+          message.aggregateValue = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.name.length; i++)
+      UninterpretedOption_NamePart.internalBinaryWrite(
+        message.name[i],
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.identifierValue !== void 0)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.identifierValue);
+    if (message.positiveIntValue !== void 0)
+      writer.tag(4, import_runtime.WireType.Varint).uint64(message.positiveIntValue);
+    if (message.negativeIntValue !== void 0)
+      writer.tag(5, import_runtime.WireType.Varint).int64(message.negativeIntValue);
+    if (message.doubleValue !== void 0)
+      writer.tag(6, import_runtime.WireType.Bit64).double(message.doubleValue);
+    if (message.stringValue !== void 0)
+      writer.tag(7, import_runtime.WireType.LengthDelimited).bytes(message.stringValue);
+    if (message.aggregateValue !== void 0)
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.aggregateValue);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const UninterpretedOption = new UninterpretedOption$Type();
+class UninterpretedOption_NamePart$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.UninterpretedOption.NamePart", [
+      {
+        no: 1,
+        name: "name_part",
+        kind: "scalar",
+        T: 9
+      },
+      {
+        no: 2,
+        name: "is_extension",
+        kind: "scalar",
+        T: 8
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.namePart = "";
+    message.isExtension = false;
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* required string name_part */
+        1:
+          message.namePart = reader.string();
+          break;
+        case /* required bool is_extension */
+        2:
+          message.isExtension = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.namePart !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.namePart);
+    if (message.isExtension !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.isExtension);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const UninterpretedOption_NamePart = new UninterpretedOption_NamePart$Type();
+class SourceCodeInfo$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.SourceCodeInfo", [
+      {
+        no: 1,
+        name: "location",
+        kind: "message",
+        repeat: 2,
+        T: () => SourceCodeInfo_Location
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.location = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.SourceCodeInfo.Location location */
+        1:
+          message.location.push(
+            SourceCodeInfo_Location.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.location.length; i++)
+      SourceCodeInfo_Location.internalBinaryWrite(
+        message.location[i],
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const SourceCodeInfo = new SourceCodeInfo$Type();
+class SourceCodeInfo_Location$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.SourceCodeInfo.Location", [
+      {
+        no: 1,
+        name: "path",
+        kind: "scalar",
+        repeat: 1,
+        T: 5
+      },
+      {
+        no: 2,
+        name: "span",
+        kind: "scalar",
+        repeat: 1,
+        T: 5
+      },
+      {
+        no: 3,
+        name: "leading_comments",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 4,
+        name: "trailing_comments",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 6,
+        name: "leading_detached_comments",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.path = [];
+    message.span = [];
+    message.leadingDetachedComments = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated int32 path = 1 [packed = true] */
+        1:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.path.push(reader.int32());
+          else message.path.push(reader.int32());
+          break;
+        case /* repeated int32 span = 2 [packed = true] */
+        2:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.span.push(reader.int32());
+          else message.span.push(reader.int32());
+          break;
+        case /* optional string leading_comments */
+        3:
+          message.leadingComments = reader.string();
+          break;
+        case /* optional string trailing_comments */
+        4:
+          message.trailingComments = reader.string();
+          break;
+        case /* repeated string leading_detached_comments */
+        6:
+          message.leadingDetachedComments.push(reader.string());
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.path.length) {
+      writer.tag(1, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0; i < message.path.length; i++)
+        writer.int32(message.path[i]);
+      writer.join();
+    }
+    if (message.span.length) {
+      writer.tag(2, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0; i < message.span.length; i++)
+        writer.int32(message.span[i]);
+      writer.join();
+    }
+    if (message.leadingComments !== void 0)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.leadingComments);
+    if (message.trailingComments !== void 0)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.trailingComments);
+    for (let i = 0; i < message.leadingDetachedComments.length; i++)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.leadingDetachedComments[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const SourceCodeInfo_Location = new SourceCodeInfo_Location$Type();
+class GeneratedCodeInfo$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.GeneratedCodeInfo", [
+      {
+        no: 1,
+        name: "annotation",
+        kind: "message",
+        repeat: 2,
+        T: () => GeneratedCodeInfo_Annotation
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.annotation = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.GeneratedCodeInfo.Annotation annotation */
+        1:
+          message.annotation.push(
+            GeneratedCodeInfo_Annotation.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.annotation.length; i++)
+      GeneratedCodeInfo_Annotation.internalBinaryWrite(
+        message.annotation[i],
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const GeneratedCodeInfo = new GeneratedCodeInfo$Type();
+class GeneratedCodeInfo_Annotation$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("google.protobuf.GeneratedCodeInfo.Annotation", [
+      {
+        no: 1,
+        name: "path",
+        kind: "scalar",
+        repeat: 1,
+        T: 5
+      },
+      {
+        no: 2,
+        name: "source_file",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "begin",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      },
+      {
+        no: 4,
+        name: "end",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.path = [];
+    if (value !== void 0)
+      (0, import_runtime3.reflectionMergePartial)(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated int32 path = 1 [packed = true] */
+        1:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.path.push(reader.int32());
+          else message.path.push(reader.int32());
+          break;
+        case /* optional string source_file */
+        2:
+          message.sourceFile = reader.string();
+          break;
+        case /* optional int32 begin */
+        3:
+          message.begin = reader.int32();
+          break;
+        case /* optional int32 end */
+        4:
+          message.end = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.path.length) {
+      writer.tag(1, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0; i < message.path.length; i++)
+        writer.int32(message.path[i]);
+      writer.join();
+    }
+    if (message.sourceFile !== void 0)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.sourceFile);
+    if (message.begin !== void 0)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.begin);
+    if (message.end !== void 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.end);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const GeneratedCodeInfo_Annotation = new GeneratedCodeInfo_Annotation$Type();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DescriptorProto,
+  DescriptorProto_ExtensionRange,
+  DescriptorProto_ReservedRange,
+  EnumDescriptorProto,
+  EnumDescriptorProto_EnumReservedRange,
+  EnumOptions,
+  EnumValueDescriptorProto,
+  EnumValueOptions,
+  ExtensionRangeOptions,
+  FieldDescriptorProto,
+  FieldDescriptorProto_Label,
+  FieldDescriptorProto_Type,
+  FieldOptions,
+  FieldOptions_CType,
+  FieldOptions_JSType,
+  FileDescriptorProto,
+  FileDescriptorSet,
+  FileOptions,
+  FileOptions_OptimizeMode,
+  GeneratedCodeInfo,
+  GeneratedCodeInfo_Annotation,
+  MessageOptions,
+  MethodDescriptorProto,
+  MethodOptions,
+  MethodOptions_IdempotencyLevel,
+  OneofDescriptorProto,
+  OneofOptions,
+  ServiceDescriptorProto,
+  ServiceOptions,
+  SourceCodeInfo,
+  SourceCodeInfo_Location,
+  UninterpretedOption,
+  UninterpretedOption_NamePart
+});
+//# sourceMappingURL=descriptor.cjs.map