@caronashow/api 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -0,0 +1,3099 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  file_google_type_latlng: () => file_google_type_latlng,
+  file_caronashow_types_v1_user: () => file_caronashow_types_v1_user,
+  file_caronashow_service_v1_map: () => file_caronashow_service_v1_map,
+  file_caronashow_pooler_v1_pooler: () => file_caronashow_pooler_v1_pooler,
+  file_caronashow_poc_v1_routes: () => file_caronashow_poc_v1_routes,
+  file_caronashow_poc_v1_points: () => file_caronashow_poc_v1_points,
+  file_caronashow_poc_v1_poc: () => file_caronashow_poc_v1_poc,
+  file_caronashow_poc_v1_groups: () => file_caronashow_poc_v1_groups,
+  VehicleSchema: () => VehicleSchema,
+  UserSchema: () => UserSchema,
+  RouteTargetTypeSchema: () => RouteTargetTypeSchema,
+  RouteTargetType: () => RouteTargetType,
+  PoolerService: () => PoolerService,
+  PocService: () => PocService,
+  PersonSchema: () => PersonSchema,
+  PersonRankSchema: () => PersonRankSchema,
+  PersonRank: () => PersonRank,
+  PersonIconSchema: () => PersonIconSchema,
+  PersonIcon: () => PersonIcon,
+  PassengerPointSchema: () => PassengerPointSchema,
+  OrganizationPointSchema: () => OrganizationPointSchema,
+  OptimizedRouteSchema: () => OptimizedRouteSchema,
+  OperationStateSchema: () => OperationStateSchema,
+  OperationState: () => OperationState,
+  OperationSchema: () => OperationSchema,
+  MatchingAlgorithmSchema: () => MatchingAlgorithmSchema,
+  MatchingAlgorithm: () => MatchingAlgorithm,
+  MatchGroupSchema: () => MatchGroupSchema,
+  MapService: () => MapService,
+  ListOperationsResponseSchema: () => ListOperationsResponseSchema,
+  ListOperationsRequestSchema: () => ListOperationsRequestSchema,
+  LatLngSchema: () => LatLngSchema,
+  GetStateOfOperationResponseSchema: () => GetStateOfOperationResponseSchema,
+  GetStateOfOperationRequestSchema: () => GetStateOfOperationRequestSchema,
+  GetOptimizedRoutesResponseSchema: () => GetOptimizedRoutesResponseSchema,
+  GetOptimizedRoutesRequestSchema: () => GetOptimizedRoutesRequestSchema,
+  GetMapPointsResponseSchema: () => GetMapPointsResponseSchema,
+  GetMapPointsRequestSchema: () => GetMapPointsRequestSchema,
+  GetMapPointGroupsResponseSchema: () => GetMapPointGroupsResponseSchema,
+  GetMapPointGroupsRequestSchema: () => GetMapPointGroupsRequestSchema,
+  GetDirectRoutesResponseSchema: () => GetDirectRoutesResponseSchema,
+  GetDirectRoutesRequestSchema: () => GetDirectRoutesRequestSchema,
+  ExecuteMatchingAlgorithmOnDatasetResponseSchema: () => ExecuteMatchingAlgorithmOnDatasetResponseSchema,
+  ExecuteMatchingAlgorithmOnDatasetRequestSchema: () => ExecuteMatchingAlgorithmOnDatasetRequestSchema,
+  DriverPointSchema: () => DriverPointSchema,
+  DirectRouteSchema: () => DirectRouteSchema,
+  DatasetSchema: () => DatasetSchema,
+  Dataset: () => Dataset,
+  AddressSchema: () => AddressSchema
+});
+module.exports = __toCommonJS(exports_src);
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js
+function protoCamelCase(snakeCase) {
+  let capNext = false;
+  const b = [];
+  for (let i = 0;i < snakeCase.length; i++) {
+    let c = snakeCase.charAt(i);
+    switch (c) {
+      case "_":
+        capNext = true;
+        break;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        b.push(c);
+        capNext = false;
+        break;
+      default:
+        if (capNext) {
+          capNext = false;
+          c = c.toUpperCase();
+        }
+        b.push(c);
+        break;
+    }
+  }
+  return b.join("");
+}
+var reservedObjectProperties = new Set([
+  "constructor",
+  "toString",
+  "toJSON",
+  "valueOf"
+]);
+function safeObjectProperty(name) {
+  return reservedObjectProperties.has(name) ? name + "$" : name;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
+function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0;shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  lowBits |= (middleByte & 15) << 28;
+  highBits = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3;shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+var TWO_PWR_32_DBL = 4294967296;
+function int64FromString(dec) {
+  const minus = dec[0] === "-";
+  if (minus) {
+    dec = dec.slice(1);
+  }
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+function int64ToString(lo, hi) {
+  let bits = newBits(lo, hi);
+  const negative = bits.hi & 2147483648;
+  if (negative) {
+    bits = negate(bits.lo, bits.hi);
+  }
+  const result = uInt64ToString(bits.lo, bits.hi);
+  return negative ? "-" + result : result;
+}
+function uInt64ToString(lo, hi) {
+  ({ lo, hi } = toUnsigned(lo, hi));
+  if (hi <= 2097151) {
+    return String(TWO_PWR_32_DBL * hi + lo);
+  }
+  const low = lo & 16777215;
+  const mid = (lo >>> 24 | hi << 8) & 16777215;
+  const high = hi >> 16 & 65535;
+  let digitA = low + mid * 6777216 + high * 6710656;
+  let digitB = mid + high * 8147497;
+  let digitC = high * 2;
+  const base = 1e7;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    digitC += Math.floor(digitB / base);
+    digitB %= base;
+  }
+  return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+  return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+  return { lo: lo | 0, hi: hi | 0 };
+}
+function negate(lowBits, highBits) {
+  highBits = ~highBits;
+  if (lowBits) {
+    lowBits = ~lowBits + 1;
+  } else {
+    highBits += 1;
+  }
+  return newBits(lowBits, highBits);
+}
+var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+  const partial = String(digit1e7);
+  return "0000000".slice(partial.length) + partial;
+};
+function varint32write(value, bytes) {
+  if (value >= 0) {
+    while (value > 127) {
+      bytes.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    bytes.push(value);
+  } else {
+    for (let i = 0;i < 9; i++) {
+      bytes.push(value & 127 | 128);
+      value = value >> 7;
+    }
+    bytes.push(1);
+  }
+}
+function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 127;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5;(b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) != 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
+var protoInt64 = /* @__PURE__ */ makeInt64Support();
+function makeInt64Support() {
+  const dv = new DataView(new ArrayBuffer(8));
+  const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808");
+    const MAX = BigInt("9223372036854775807");
+    const UMIN = BigInt("0");
+    const UMAX = BigInt("18446744073709551615");
+    return {
+      zero: BigInt(0),
+      supported: true,
+      parse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > MAX || bi < MIN) {
+          throw new Error(`invalid int64: ${value}`);
+        }
+        return bi;
+      },
+      uParse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > UMAX || bi < UMIN) {
+          throw new Error(`invalid uint64: ${value}`);
+        }
+        return bi;
+      },
+      enc(value) {
+        dv.setBigInt64(0, this.parse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      uEnc(value) {
+        dv.setBigInt64(0, this.uParse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      dec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigInt64(0, true);
+      },
+      uDec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigUint64(0, true);
+      }
+    };
+  }
+  return {
+    zero: "0",
+    supported: false,
+    parse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return value;
+    },
+    uParse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return value;
+    },
+    enc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return int64FromString(value);
+    },
+    uEnc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return int64FromString(value);
+    },
+    dec(lo, hi) {
+      return int64ToString(lo, hi);
+    },
+    uDec(lo, hi) {
+      return uInt64ToString(lo, hi);
+    }
+  };
+}
+function assertInt64String(value) {
+  if (!/^-?[0-9]+$/.test(value)) {
+    throw new Error("invalid int64: " + value);
+  }
+}
+function assertUInt64String(value) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new Error("invalid uint64: " + value);
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/descriptors.js
+var ScalarType;
+(function(ScalarType2) {
+  ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
+  ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
+  ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
+  ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
+  ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
+  ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
+  ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
+  ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
+  ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
+  ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
+  ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
+  ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
+  ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
+  ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
+  ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
+})(ScalarType || (ScalarType = {}));
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js
+function scalarZeroValue(type, longAsString) {
+  switch (type) {
+    case ScalarType.STRING:
+      return "";
+    case ScalarType.BOOL:
+      return false;
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      return 0;
+    case ScalarType.INT64:
+    case ScalarType.UINT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.FIXED64:
+    case ScalarType.SINT64:
+      return longAsString ? "0" : protoInt64.zero;
+    case ScalarType.BYTES:
+      return new Uint8Array(0);
+    default:
+      return 0;
+  }
+}
+function isScalarZeroValue(type, value) {
+  switch (type) {
+    case ScalarType.BOOL:
+      return value === false;
+    case ScalarType.STRING:
+      return value === "";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array && !value.byteLength;
+    default:
+      return value == 0;
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js
+var IMPLICIT = 2;
+var unsafeLocal = Symbol.for("reflect unsafe local");
+function unsafeOneofCase(target, oneof) {
+  const c = target[oneof.localName].case;
+  if (c === undefined) {
+    return c;
+  }
+  return oneof.fields.find((f) => f.localName === c);
+}
+function unsafeIsSet(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    return target[field.oneof.localName].case === name;
+  }
+  if (field.presence != IMPLICIT) {
+    return target[name] !== undefined && Object.prototype.hasOwnProperty.call(target, name);
+  }
+  switch (field.fieldKind) {
+    case "list":
+      return target[name].length > 0;
+    case "map":
+      return Object.keys(target[name]).length > 0;
+    case "scalar":
+      return !isScalarZeroValue(field.scalar, target[name]);
+    case "enum":
+      return target[name] !== field.enum.values[0].number;
+  }
+  throw new Error("message field with implicit presence");
+}
+function unsafeIsSetExplicit(target, localName) {
+  return Object.prototype.hasOwnProperty.call(target, localName) && target[localName] !== undefined;
+}
+function unsafeGet(target, field) {
+  if (field.oneof) {
+    const oneof = target[field.oneof.localName];
+    if (oneof.case === field.localName) {
+      return oneof.value;
+    }
+    return;
+  }
+  return target[field.localName];
+}
+function unsafeSet(target, field, value) {
+  if (field.oneof) {
+    target[field.oneof.localName] = {
+      case: field.localName,
+      value
+    };
+  } else {
+    target[field.localName] = value;
+  }
+}
+function unsafeClear(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    const oneofLocalName = field.oneof.localName;
+    if (target[oneofLocalName].case === name) {
+      target[oneofLocalName] = { case: undefined };
+    }
+  } else if (field.presence != IMPLICIT) {
+    delete target[name];
+  } else {
+    switch (field.fieldKind) {
+      case "map":
+        target[name] = {};
+        break;
+      case "list":
+        target[name] = [];
+        break;
+      case "enum":
+        target[name] = field.enum.values[0].number;
+        break;
+      case "scalar":
+        target[name] = scalarZeroValue(field.scalar, field.longAsString);
+        break;
+    }
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.js
+function restoreJsonNames(message) {
+  for (const f of message.field) {
+    if (!unsafeIsSetExplicit(f, "jsonName")) {
+      f.jsonName = protoCamelCase(f.name);
+    }
+  }
+  message.nestedType.forEach(restoreJsonNames);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js
+function parseTextFormatEnumValue(descEnum, value) {
+  const enumValue = descEnum.values.find((v) => v.name === value);
+  if (!enumValue) {
+    throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+  }
+  return enumValue.number;
+}
+function parseTextFormatScalarValue(type, value) {
+  switch (type) {
+    case ScalarType.STRING:
+      return value;
+    case ScalarType.BYTES: {
+      const u = unescapeBytesDefaultValue(value);
+      if (u === false) {
+        throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`);
+      }
+      return u;
+    }
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      return protoInt64.parse(value);
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return protoInt64.uParse(value);
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      switch (value) {
+        case "inf":
+          return Number.POSITIVE_INFINITY;
+        case "-inf":
+          return Number.NEGATIVE_INFINITY;
+        case "nan":
+          return Number.NaN;
+        default:
+          return parseFloat(value);
+      }
+    case ScalarType.BOOL:
+      return value === "true";
+    case ScalarType.INT32:
+    case ScalarType.UINT32:
+    case ScalarType.SINT32:
+    case ScalarType.FIXED32:
+    case ScalarType.SFIXED32:
+      return parseInt(value, 10);
+  }
+}
+function unescapeBytesDefaultValue(str) {
+  const b = [];
+  const input = {
+    tail: str,
+    c: "",
+    next() {
+      if (this.tail.length == 0) {
+        return false;
+      }
+      this.c = this.tail[0];
+      this.tail = this.tail.substring(1);
+      return true;
+    },
+    take(n) {
+      if (this.tail.length >= n) {
+        const r = this.tail.substring(0, n);
+        this.tail = this.tail.substring(n);
+        return r;
+      }
+      return false;
+    }
+  };
+  while (input.next()) {
+    switch (input.c) {
+      case "\\":
+        if (input.next()) {
+          switch (input.c) {
+            case "\\":
+              b.push(input.c.charCodeAt(0));
+              break;
+            case "b":
+              b.push(8);
+              break;
+            case "f":
+              b.push(12);
+              break;
+            case "n":
+              b.push(10);
+              break;
+            case "r":
+              b.push(13);
+              break;
+            case "t":
+              b.push(9);
+              break;
+            case "v":
+              b.push(11);
+              break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 8);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "x": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "u": {
+              const s = input.c;
+              const t = input.take(4);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (Number.isNaN(n)) {
+                return false;
+              }
+              const chunk = new Uint8Array(4);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, n, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+              break;
+            }
+            case "U": {
+              const s = input.c;
+              const t = input.take(8);
+              if (t === false) {
+                return false;
+              }
+              const tc = protoInt64.uEnc(s + t);
+              const chunk = new Uint8Array(8);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, tc.lo, true);
+              view.setInt32(4, tc.hi, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+              break;
+            }
+          }
+        }
+        break;
+      default:
+        b.push(input.c.charCodeAt(0));
+    }
+  }
+  return new Uint8Array(b);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js
+function* nestedTypes(desc) {
+  switch (desc.kind) {
+    case "file":
+      for (const message of desc.messages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.enums;
+      yield* desc.services;
+      yield* desc.extensions;
+      break;
+    case "message":
+      for (const message of desc.nestedMessages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.nestedEnums;
+      yield* desc.nestedExtensions;
+      break;
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/registry.js
+function createFileRegistry(...args) {
+  const registry = createBaseRegistry();
+  if (!args.length) {
+    return registry;
+  }
+  if ("$typeName" in args[0] && args[0].$typeName == "google.protobuf.FileDescriptorSet") {
+    for (const file of args[0].file) {
+      addFile(file, registry);
+    }
+    return registry;
+  }
+  if ("$typeName" in args[0]) {
+    let recurseDeps = function(file) {
+      const deps = [];
+      for (const protoFileName of file.dependency) {
+        if (registry.getFile(protoFileName) != null) {
+          continue;
+        }
+        if (seen.has(protoFileName)) {
+          continue;
+        }
+        const dep = resolve(protoFileName);
+        if (!dep) {
+          throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
+        }
+        if ("kind" in dep) {
+          registry.addFile(dep, false, true);
+        } else {
+          seen.add(dep.name);
+          deps.push(dep);
+        }
+      }
+      return deps.concat(...deps.map(recurseDeps));
+    };
+    const input = args[0];
+    const resolve = args[1];
+    const seen = new Set;
+    for (const file of [input, ...recurseDeps(input)].reverse()) {
+      addFile(file, registry);
+    }
+  } else {
+    for (const fileReg of args) {
+      for (const file of fileReg.files) {
+        registry.addFile(file);
+      }
+    }
+  }
+  return registry;
+}
+function createBaseRegistry() {
+  const types = new Map;
+  const extendees = new Map;
+  const files = new Map;
+  return {
+    kind: "registry",
+    types,
+    extendees,
+    [Symbol.iterator]() {
+      return types.values();
+    },
+    get files() {
+      return files.values();
+    },
+    addFile(file, skipTypes, withDeps) {
+      files.set(file.proto.name, file);
+      if (!skipTypes) {
+        for (const type of nestedTypes(file)) {
+          this.add(type);
+        }
+      }
+      if (withDeps) {
+        for (const f of file.dependencies) {
+          this.addFile(f, skipTypes, withDeps);
+        }
+      }
+    },
+    add(desc) {
+      if (desc.kind == "extension") {
+        let numberToExt = extendees.get(desc.extendee.typeName);
+        if (!numberToExt) {
+          extendees.set(desc.extendee.typeName, numberToExt = new Map);
+        }
+        numberToExt.set(desc.number, desc);
+      }
+      types.set(desc.typeName, desc);
+    },
+    get(typeName) {
+      return types.get(typeName);
+    },
+    getFile(fileName) {
+      return files.get(fileName);
+    },
+    getMessage(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === undefined ? undefined : t.kind) == "message" ? t : undefined;
+    },
+    getEnum(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === undefined ? undefined : t.kind) == "enum" ? t : undefined;
+    },
+    getExtension(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === undefined ? undefined : t.kind) == "extension" ? t : undefined;
+    },
+    getExtensionFor(extendee, no) {
+      var _a;
+      return (_a = extendees.get(extendee.typeName)) === null || _a === undefined ? undefined : _a.get(no);
+    },
+    getService(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === undefined ? undefined : t.kind) == "service" ? t : undefined;
+    }
+  };
+}
+var EDITION_PROTO2 = 998;
+var EDITION_PROTO3 = 999;
+var TYPE_STRING = 9;
+var TYPE_GROUP = 10;
+var TYPE_MESSAGE = 11;
+var TYPE_BYTES = 12;
+var TYPE_ENUM = 14;
+var LABEL_REPEATED = 3;
+var LABEL_REQUIRED = 2;
+var JS_STRING = 1;
+var IDEMPOTENCY_UNKNOWN = 0;
+var EXPLICIT = 1;
+var IMPLICIT2 = 2;
+var LEGACY_REQUIRED = 3;
+var PACKED = 1;
+var DELIMITED = 2;
+var OPEN = 1;
+var featureDefaults = {
+  998: {
+    fieldPresence: 1,
+    enumType: 2,
+    repeatedFieldEncoding: 2,
+    utf8Validation: 3,
+    messageEncoding: 1,
+    jsonFormat: 2,
+    enforceNamingStyle: 2,
+    defaultSymbolVisibility: 1
+  },
+  999: {
+    fieldPresence: 2,
+    enumType: 1,
+    repeatedFieldEncoding: 1,
+    utf8Validation: 2,
+    messageEncoding: 1,
+    jsonFormat: 1,
+    enforceNamingStyle: 2,
+    defaultSymbolVisibility: 1
+  },
+  1000: {
+    fieldPresence: 1,
+    enumType: 1,
+    repeatedFieldEncoding: 1,
+    utf8Validation: 2,
+    messageEncoding: 1,
+    jsonFormat: 1,
+    enforceNamingStyle: 2,
+    defaultSymbolVisibility: 1
+  },
+  1001: {
+    fieldPresence: 1,
+    enumType: 1,
+    repeatedFieldEncoding: 1,
+    utf8Validation: 2,
+    messageEncoding: 1,
+    jsonFormat: 1,
+    enforceNamingStyle: 1,
+    defaultSymbolVisibility: 2
+  }
+};
+function addFile(proto, reg) {
+  var _a, _b;
+  const file = {
+    kind: "file",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    edition: getFileEdition(proto),
+    name: proto.name.replace(/\.proto$/, ""),
+    dependencies: findFileDependencies(proto, reg),
+    enums: [],
+    messages: [],
+    extensions: [],
+    services: [],
+    toString() {
+      return `file ${proto.name}`;
+    }
+  };
+  const mapEntriesStore = new Map;
+  const mapEntries = {
+    get(typeName) {
+      return mapEntriesStore.get(typeName);
+    },
+    add(desc) {
+      var _a2;
+      assert(((_a2 = desc.proto.options) === null || _a2 === undefined ? undefined : _a2.mapEntry) === true);
+      mapEntriesStore.set(desc.typeName, desc);
+    }
+  };
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, undefined, reg);
+  }
+  for (const messageProto of proto.messageType) {
+    addMessage(messageProto, file, undefined, reg, mapEntries);
+  }
+  for (const serviceProto of proto.service) {
+    addService(serviceProto, file, reg);
+  }
+  addExtensions(file, reg);
+  for (const mapEntry of mapEntriesStore.values()) {
+    addFields(mapEntry, reg, mapEntries);
+  }
+  for (const message of file.messages) {
+    addFields(message, reg, mapEntries);
+    addExtensions(message, reg);
+  }
+  reg.addFile(file, true);
+}
+function addExtensions(desc, reg) {
+  switch (desc.kind) {
+    case "file":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.extensions.push(ext);
+        reg.add(ext);
+      }
+      break;
+    case "message":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.nestedExtensions.push(ext);
+        reg.add(ext);
+      }
+      for (const message of desc.nestedMessages) {
+        addExtensions(message, reg);
+      }
+      break;
+  }
+}
+function addFields(message, reg, mapEntries) {
+  const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+  const oneofsSeen = new Set;
+  for (const proto of message.proto.field) {
+    const oneof = findOneof(proto, allOneofs);
+    const field = newField(proto, message, reg, oneof, mapEntries);
+    message.fields.push(field);
+    message.field[field.localName] = field;
+    if (oneof === undefined) {
+      message.members.push(field);
+    } else {
+      oneof.fields.push(field);
+      if (!oneofsSeen.has(oneof)) {
+        oneofsSeen.add(oneof);
+        message.members.push(oneof);
+      }
+    }
+  }
+  for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) {
+    message.oneofs.push(oneof);
+  }
+  for (const child of message.nestedMessages) {
+    addFields(child, reg, mapEntries);
+  }
+}
+function addEnum(proto, file, parent, reg) {
+  var _a, _b, _c, _d, _e;
+  const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value);
+  const desc = {
+    kind: "enum",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    file,
+    parent,
+    open: true,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    value: {},
+    values: [],
+    sharedPrefix,
+    toString() {
+      return `enum ${this.typeName}`;
+    }
+  };
+  desc.open = isEnumOpen(desc);
+  reg.add(desc);
+  for (const p of proto.value) {
+    const name = p.name;
+    desc.values.push(desc.value[p.number] = {
+      kind: "enum_value",
+      proto: p,
+      deprecated: (_d = (_c = p.options) === null || _c === undefined ? undefined : _c.deprecated) !== null && _d !== undefined ? _d : false,
+      parent: desc,
+      name,
+      localName: safeObjectProperty(sharedPrefix == undefined ? name : name.substring(sharedPrefix.length)),
+      number: p.number,
+      toString() {
+        return `enum value ${desc.typeName}.${name}`;
+      }
+    });
+  }
+  ((_e = parent === null || parent === undefined ? undefined : parent.nestedEnums) !== null && _e !== undefined ? _e : file.enums).push(desc);
+}
+function addMessage(proto, file, parent, reg, mapEntries) {
+  var _a, _b, _c, _d;
+  const desc = {
+    kind: "message",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    file,
+    parent,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    fields: [],
+    field: {},
+    oneofs: [],
+    members: [],
+    nestedEnums: [],
+    nestedMessages: [],
+    nestedExtensions: [],
+    toString() {
+      return `message ${this.typeName}`;
+    }
+  };
+  if (((_c = proto.options) === null || _c === undefined ? undefined : _c.mapEntry) === true) {
+    mapEntries.add(desc);
+  } else {
+    ((_d = parent === null || parent === undefined ? undefined : parent.nestedMessages) !== null && _d !== undefined ? _d : file.messages).push(desc);
+    reg.add(desc);
+  }
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, desc, reg);
+  }
+  for (const messageProto of proto.nestedType) {
+    addMessage(messageProto, file, desc, reg, mapEntries);
+  }
+}
+function addService(proto, file, reg) {
+  var _a, _b;
+  const desc = {
+    kind: "service",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    file,
+    name: proto.name,
+    typeName: makeTypeName(proto, undefined, file),
+    methods: [],
+    method: {},
+    toString() {
+      return `service ${this.typeName}`;
+    }
+  };
+  file.services.push(desc);
+  reg.add(desc);
+  for (const methodProto of proto.method) {
+    const method = newMethod(methodProto, desc, reg);
+    desc.methods.push(method);
+    desc.method[method.localName] = method;
+  }
+}
+function newMethod(proto, parent, reg) {
+  var _a, _b, _c, _d;
+  let methodKind;
+  if (proto.clientStreaming && proto.serverStreaming) {
+    methodKind = "bidi_streaming";
+  } else if (proto.clientStreaming) {
+    methodKind = "client_streaming";
+  } else if (proto.serverStreaming) {
+    methodKind = "server_streaming";
+  } else {
+    methodKind = "unary";
+  }
+  const input = reg.getMessage(trimLeadingDot(proto.inputType));
+  const output = reg.getMessage(trimLeadingDot(proto.outputType));
+  assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+  assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
+  const name = proto.name;
+  return {
+    kind: "rpc",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    parent,
+    name,
+    localName: safeObjectProperty(name.length ? safeObjectProperty(name[0].toLowerCase() + name.substring(1)) : name),
+    methodKind,
+    input,
+    output,
+    idempotency: (_d = (_c = proto.options) === null || _c === undefined ? undefined : _c.idempotencyLevel) !== null && _d !== undefined ? _d : IDEMPOTENCY_UNKNOWN,
+    toString() {
+      return `rpc ${parent.typeName}.${name}`;
+    }
+  };
+}
+function newOneof(proto, parent) {
+  return {
+    kind: "oneof",
+    proto,
+    deprecated: false,
+    parent,
+    fields: [],
+    name: proto.name,
+    localName: safeObjectProperty(protoCamelCase(proto.name)),
+    toString() {
+      return `oneof ${parent.typeName}.${this.name}`;
+    }
+  };
+}
+function newField(proto, parentOrFile, reg, oneof, mapEntries) {
+  var _a, _b, _c;
+  const isExtension = mapEntries === undefined;
+  const field = {
+    kind: "field",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === undefined ? undefined : _a.deprecated) !== null && _b !== undefined ? _b : false,
+    name: proto.name,
+    number: proto.number,
+    scalar: undefined,
+    message: undefined,
+    enum: undefined,
+    presence: getFieldPresence(proto, oneof, isExtension, parentOrFile),
+    listKind: undefined,
+    mapKind: undefined,
+    mapKey: undefined,
+    delimitedEncoding: undefined,
+    packed: undefined,
+    longAsString: false,
+    getDefaultValue: undefined
+  };
+  if (isExtension) {
+    const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
+    const parent = parentOrFile.kind == "file" ? undefined : parentOrFile;
+    const typeName = makeTypeName(proto, parent, file);
+    field.kind = "extension";
+    field.file = file;
+    field.parent = parent;
+    field.oneof = undefined;
+    field.typeName = typeName;
+    field.jsonName = `[${typeName}]`;
+    field.toString = () => `extension ${typeName}`;
+    const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
+    assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+    field.extendee = extendee;
+  } else {
+    const parent = parentOrFile;
+    assert(parent.kind == "message");
+    field.parent = parent;
+    field.oneof = oneof;
+    field.localName = oneof ? protoCamelCase(proto.name) : safeObjectProperty(protoCamelCase(proto.name));
+    field.jsonName = proto.jsonName;
+    field.toString = () => `field ${parent.typeName}.${proto.name}`;
+  }
+  const label = proto.label;
+  const type = proto.type;
+  const jstype = (_c = proto.options) === null || _c === undefined ? undefined : _c.jstype;
+  if (label === LABEL_REPEATED) {
+    const mapEntry = type == TYPE_MESSAGE ? mapEntries === null || mapEntries === undefined ? undefined : mapEntries.get(trimLeadingDot(proto.typeName)) : undefined;
+    if (mapEntry) {
+      field.fieldKind = "map";
+      const { key, value } = findMapEntryFields(mapEntry);
+      field.mapKey = key.scalar;
+      field.mapKind = value.fieldKind;
+      field.message = value.message;
+      field.delimitedEncoding = false;
+      field.enum = value.enum;
+      field.scalar = value.scalar;
+      return field;
+    }
+    field.fieldKind = "list";
+    switch (type) {
+      case TYPE_MESSAGE:
+      case TYPE_GROUP:
+        field.listKind = "message";
+        field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+        assert(field.message);
+        field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+        break;
+      case TYPE_ENUM:
+        field.listKind = "enum";
+        field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+        assert(field.enum);
+        break;
+      default:
+        field.listKind = "scalar";
+        field.scalar = type;
+        field.longAsString = jstype == JS_STRING;
+        break;
+    }
+    field.packed = isPackedField(proto, parentOrFile);
+    return field;
+  }
+  switch (type) {
+    case TYPE_MESSAGE:
+    case TYPE_GROUP:
+      field.fieldKind = "message";
+      field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+      assert(field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+      field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+      field.getDefaultValue = () => {
+        return;
+      };
+      break;
+    case TYPE_ENUM: {
+      const enumeration = reg.getEnum(trimLeadingDot(proto.typeName));
+      assert(enumeration !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+      field.fieldKind = "enum";
+      field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatEnumValue(enumeration, proto.defaultValue) : undefined;
+      };
+      break;
+    }
+    default: {
+      field.fieldKind = "scalar";
+      field.scalar = type;
+      field.longAsString = jstype == JS_STRING;
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatScalarValue(type, proto.defaultValue) : undefined;
+      };
+      break;
+    }
+  }
+  return field;
+}
+function getFileEdition(proto) {
+  switch (proto.syntax) {
+    case "":
+    case "proto2":
+      return EDITION_PROTO2;
+    case "proto3":
+      return EDITION_PROTO3;
+    case "editions":
+      if (proto.edition in featureDefaults) {
+        return proto.edition;
+      }
+      throw new Error(`${proto.name}: unsupported edition`);
+    default:
+      throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`);
+  }
+}
+function findFileDependencies(proto, reg) {
+  return proto.dependency.map((wantName) => {
+    const dep = reg.getFile(wantName);
+    if (!dep) {
+      throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`);
+    }
+    return dep;
+  });
+}
+function findEnumSharedPrefix(enumName, values) {
+  const prefix = camelToSnakeCase(enumName) + "_";
+  for (const value of values) {
+    if (!value.name.toLowerCase().startsWith(prefix)) {
+      return;
+    }
+    const shortName = value.name.substring(prefix.length);
+    if (shortName.length == 0) {
+      return;
+    }
+    if (/^\d/.test(shortName)) {
+      return;
+    }
+  }
+  return prefix;
+}
+function camelToSnakeCase(camel) {
+  return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+function makeTypeName(proto, parent, file) {
+  let typeName;
+  if (parent) {
+    typeName = `${parent.typeName}.${proto.name}`;
+  } else if (file.proto.package.length > 0) {
+    typeName = `${file.proto.package}.${proto.name}`;
+  } else {
+    typeName = `${proto.name}`;
+  }
+  return typeName;
+}
+function trimLeadingDot(typeName) {
+  return typeName.startsWith(".") ? typeName.substring(1) : typeName;
+}
+function findOneof(proto, allOneofs) {
+  if (!unsafeIsSetExplicit(proto, "oneofIndex")) {
+    return;
+  }
+  if (proto.proto3Optional) {
+    return;
+  }
+  const oneof = allOneofs[proto.oneofIndex];
+  assert(oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`);
+  return oneof;
+}
+function getFieldPresence(proto, oneof, isExtension, parent) {
+  if (proto.label == LABEL_REQUIRED) {
+    return LEGACY_REQUIRED;
+  }
+  if (proto.label == LABEL_REPEATED) {
+    return IMPLICIT2;
+  }
+  if (!!oneof || proto.proto3Optional) {
+    return EXPLICIT;
+  }
+  if (isExtension) {
+    return EXPLICIT;
+  }
+  const resolved = resolveFeature("fieldPresence", { proto, parent });
+  if (resolved == IMPLICIT2 && (proto.type == TYPE_MESSAGE || proto.type == TYPE_GROUP)) {
+    return EXPLICIT;
+  }
+  return resolved;
+}
+function isPackedField(proto, parent) {
+  if (proto.label != LABEL_REPEATED) {
+    return false;
+  }
+  switch (proto.type) {
+    case TYPE_STRING:
+    case TYPE_BYTES:
+    case TYPE_GROUP:
+    case TYPE_MESSAGE:
+      return false;
+  }
+  const o = proto.options;
+  if (o && unsafeIsSetExplicit(o, "packed")) {
+    return o.packed;
+  }
+  return PACKED == resolveFeature("repeatedFieldEncoding", {
+    proto,
+    parent
+  });
+}
+function findMapEntryFields(mapEntry) {
+  const key = mapEntry.fields.find((f) => f.number === 1);
+  const value = mapEntry.fields.find((f) => f.number === 2);
+  assert(key && key.fieldKind == "scalar" && key.scalar != ScalarType.BYTES && key.scalar != ScalarType.FLOAT && key.scalar != ScalarType.DOUBLE && value && value.fieldKind != "list" && value.fieldKind != "map");
+  return { key, value };
+}
+function isEnumOpen(desc) {
+  var _a;
+  return OPEN == resolveFeature("enumType", {
+    proto: desc.proto,
+    parent: (_a = desc.parent) !== null && _a !== undefined ? _a : desc.file
+  });
+}
+function isDelimitedEncoding(proto, parent) {
+  if (proto.type == TYPE_GROUP) {
+    return true;
+  }
+  return DELIMITED == resolveFeature("messageEncoding", {
+    proto,
+    parent
+  });
+}
+function resolveFeature(name, ref) {
+  var _a, _b;
+  const featureSet = (_a = ref.proto.options) === null || _a === undefined ? undefined : _a.features;
+  if (featureSet) {
+    const val = featureSet[name];
+    if (val != 0) {
+      return val;
+    }
+  }
+  if ("kind" in ref) {
+    if (ref.kind == "message") {
+      return resolveFeature(name, (_b = ref.parent) !== null && _b !== undefined ? _b : ref.file);
+    }
+    const editionDefaults = featureDefaults[ref.edition];
+    if (!editionDefaults) {
+      throw new Error(`feature default for edition ${ref.edition} not found`);
+    }
+    return editionDefaults[name];
+  }
+  return resolveFeature(name, ref.parent);
+}
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.js
+function boot(boot2) {
+  const root = bootFileDescriptorProto(boot2);
+  root.messageType.forEach(restoreJsonNames);
+  const reg = createFileRegistry(root, () => {
+    return;
+  });
+  return reg.getFile(root.name);
+}
+function bootFileDescriptorProto(init) {
+  const proto = Object.create({
+    syntax: "",
+    edition: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], optionDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) }));
+}
+function bootDescriptorProto(init) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const proto = Object.create({
+    visibility: 0
+  });
+  return Object.assign(proto, {
+    $typeName: "google.protobuf.DescriptorProto",
+    name: init.name,
+    field: (_b = (_a = init.field) === null || _a === undefined ? undefined : _a.map(bootFieldDescriptorProto)) !== null && _b !== undefined ? _b : [],
+    extension: [],
+    nestedType: (_d = (_c = init.nestedType) === null || _c === undefined ? undefined : _c.map(bootDescriptorProto)) !== null && _d !== undefined ? _d : [],
+    enumType: (_f = (_e = init.enumType) === null || _e === undefined ? undefined : _e.map(bootEnumDescriptorProto)) !== null && _f !== undefined ? _f : [],
+    extensionRange: (_h = (_g = init.extensionRange) === null || _g === undefined ? undefined : _g.map((e) => Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e))) !== null && _h !== undefined ? _h : [],
+    oneofDecl: [],
+    reservedRange: [],
+    reservedName: []
+  });
+}
+function bootFieldDescriptorProto(init) {
+  const proto = Object.create({
+    label: 1,
+    typeName: "",
+    extendee: "",
+    defaultValue: "",
+    oneofIndex: 0,
+    jsonName: "",
+    proto3Optional: false
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : undefined }));
+}
+function bootFieldOptions(init) {
+  var _a, _b, _c;
+  const proto = Object.create({
+    ctype: 0,
+    packed: false,
+    jstype: 0,
+    lazy: false,
+    unverifiedLazy: false,
+    deprecated: false,
+    weak: false,
+    debugRedact: false,
+    retention: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== undefined ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === undefined ? undefined : _b.map((e) => Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e))) !== null && _c !== undefined ? _c : [], uninterpretedOption: [] }));
+}
+function bootEnumDescriptorProto(init) {
+  const proto = Object.create({
+    visibility: 0
+  });
+  return Object.assign(proto, {
+    $typeName: "google.protobuf.EnumDescriptorProto",
+    name: init.name,
+    reservedName: [],
+    reservedRange: [],
+    value: init.value.map((e) => Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))
+  });
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js
+function base64Decode(base64Str) {
+  const table = getDecodeTable();
+  let es = base64Str.length * 3 / 4;
+  if (base64Str[base64Str.length - 2] == "=")
+    es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=")
+    es -= 1;
+  let bytes = new Uint8Array(es), bytePos = 0, groupPos = 0, b, p = 0;
+  for (let i = 0;i < base64Str.length; i++) {
+    b = table[base64Str.charCodeAt(i)];
+    if (b === undefined) {
+      switch (base64Str[i]) {
+        case "=":
+          groupPos = 0;
+        case `
+`:
+        case "\r":
+        case "\t":
+        case " ":
+          continue;
+        default:
+          throw Error("invalid base64 string");
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = p << 2 | (b & 48) >> 4;
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = (p & 3) << 6 | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1)
+    throw Error("invalid base64 string");
+  return bytes.subarray(0, bytePos);
+}
+var encodeTableStd;
+var encodeTableUrl;
+var decodeTable;
+function getEncodeTable(encoding) {
+  if (!encodeTableStd) {
+    encodeTableStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_");
+  }
+  return encoding == "url" ? encodeTableUrl : encodeTableStd;
+}
+function getDecodeTable() {
+  if (!decodeTable) {
+    decodeTable = [];
+    const encodeTable = getEncodeTable("std");
+    for (let i = 0;i < encodeTable.length; i++)
+      decodeTable[encodeTable[i].charCodeAt(0)] = i;
+    decodeTable[45] = encodeTable.indexOf("+");
+    decodeTable[95] = encodeTable.indexOf("/");
+  }
+  return decodeTable;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/is-message.js
+function isMessage(arg, schema) {
+  const isMessage2 = arg !== null && typeof arg == "object" && "$typeName" in arg && typeof arg.$typeName == "string";
+  if (!isMessage2) {
+    return false;
+  }
+  if (schema === undefined) {
+    return true;
+  }
+  return schema.typeName === arg.$typeName;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/error.js
+class FieldError extends Error {
+  constructor(fieldOrOneof, message, name = "FieldValueInvalidError") {
+    super(message);
+    this.name = name;
+    this.field = () => fieldOrOneof;
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.js
+function isObject(arg) {
+  return arg !== null && typeof arg == "object" && !Array.isArray(arg);
+}
+function isReflectList(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "add" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== undefined) {
+      const a = field;
+      const b = arg.field();
+      return a.listKind == b.listKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === undefined ? undefined : _a.typeName) === ((_b = b.message) === null || _b === undefined ? undefined : _b.typeName) && ((_c = a.enum) === null || _c === undefined ? undefined : _c.typeName) === ((_d = b.enum) === null || _d === undefined ? undefined : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMap(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "has" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== undefined) {
+      const a = field, b = arg.field();
+      return a.mapKey === b.mapKey && a.mapKind == b.mapKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === undefined ? undefined : _a.typeName) === ((_b = b.message) === null || _b === undefined ? undefined : _b.typeName) && ((_c = a.enum) === null || _c === undefined ? undefined : _c.typeName) === ((_d = b.enum) === null || _d === undefined ? undefined : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMessage(arg, messageDesc) {
+  return isObject(arg) && unsafeLocal in arg && "desc" in arg && isObject(arg.desc) && arg.desc.kind === "message" && (messageDesc === undefined || arg.desc.typeName == messageDesc.typeName);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
+var symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+function getTextEncoding() {
+  if (globalThis[symbol] == undefined) {
+    const te = new globalThis.TextEncoder;
+    const td = new globalThis.TextDecoder;
+    globalThis[symbol] = {
+      encodeUtf8(text) {
+        return te.encode(text);
+      },
+      decodeUtf8(bytes) {
+        return td.decode(bytes);
+      },
+      checkUtf8(text) {
+        try {
+          encodeURIComponent(text);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      }
+    };
+  }
+  return globalThis[symbol];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
+var WireType;
+(function(WireType2) {
+  WireType2[WireType2["Varint"] = 0] = "Varint";
+  WireType2[WireType2["Bit64"] = 1] = "Bit64";
+  WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
+  WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
+  WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
+  WireType2[WireType2["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+var FLOAT32_MAX = 340282346638528860000000000000000000000;
+var FLOAT32_MIN = -340282346638528860000000000000000000000;
+var UINT32_MAX = 4294967295;
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
+class BinaryReader {
+  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
+    this.decodeUtf8 = decodeUtf8;
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  tag() {
+    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    return [fieldNo, wireType];
+  }
+  skip(wireType, fieldNo) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {}
+        break;
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        for (;; ) {
+          const [fn, wt] = this.tag();
+          if (wt === WireType.EndGroup) {
+            if (fieldNo !== undefined && fn !== fieldNo) {
+              throw new Error("invalid end group tag");
+            }
+            break;
+          }
+          this.skip(wt, fn);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, this.pos);
+  }
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  int32() {
+    return this.uint32() | 0;
+  }
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  int64() {
+    return protoInt64.dec(...this.varint64());
+  }
+  uint64() {
+    return protoInt64.uDec(...this.varint64());
+  }
+  sint64() {
+    let [lo, hi] = this.varint64();
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return protoInt64.dec(lo, hi);
+  }
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js
+function checkField(field, value) {
+  const check = field.fieldKind == "list" ? isReflectList(value, field) : field.fieldKind == "map" ? isReflectMap(value, field) : checkSingular(field, value);
+  if (check === true) {
+    return;
+  }
+  let reason;
+  switch (field.fieldKind) {
+    case "list":
+      reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`;
+      break;
+    case "map":
+      reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`;
+      break;
+    default: {
+      reason = reasonSingular(field, value, check);
+    }
+  }
+  return new FieldError(field, reason);
+}
+function checkListItem(field, index, value) {
+  const check = checkSingular(field, value);
+  if (check !== true) {
+    return new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+  }
+  return;
+}
+function checkMapEntry(field, key, value) {
+  const checkKey = checkScalarValue(key, field.mapKey);
+  if (checkKey !== true) {
+    return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+  }
+  const checkVal = checkSingular(field, value);
+  if (checkVal !== true) {
+    return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+  }
+  return;
+}
+function checkSingular(field, value) {
+  if (field.scalar !== undefined) {
+    return checkScalarValue(value, field.scalar);
+  }
+  if (field.enum !== undefined) {
+    if (field.enum.open) {
+      return Number.isInteger(value);
+    }
+    return field.enum.values.some((v) => v.number === value);
+  }
+  return isReflectMessage(value, field.message);
+}
+function checkScalarValue(value, scalar) {
+  switch (scalar) {
+    case ScalarType.DOUBLE:
+      return typeof value == "number";
+    case ScalarType.FLOAT:
+      if (typeof value != "number") {
+        return false;
+      }
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        return true;
+      }
+      if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > INT32_MAX || value < INT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > UINT32_MAX || value < 0) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.BOOL:
+      return typeof value == "boolean";
+    case ScalarType.STRING:
+      if (typeof value != "string") {
+        return false;
+      }
+      return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array;
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.parse(value);
+          return true;
+        } catch (_) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.uParse(value);
+          return true;
+        } catch (_) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+  }
+}
+function reasonSingular(field, val, details) {
+  details = typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
+  if (field.scalar !== undefined) {
+    return `expected ${scalarTypeDescription(field.scalar)}` + details;
+  }
+  if (field.enum !== undefined) {
+    return `expected ${field.enum.toString()}` + details;
+  }
+  return `expected ${formatReflectMessage(field.message)}` + details;
+}
+function formatVal(val) {
+  switch (typeof val) {
+    case "object":
+      if (val === null) {
+        return "null";
+      }
+      if (val instanceof Uint8Array) {
+        return `Uint8Array(${val.length})`;
+      }
+      if (Array.isArray(val)) {
+        return `Array(${val.length})`;
+      }
+      if (isReflectList(val)) {
+        return formatReflectList(val.field());
+      }
+      if (isReflectMap(val)) {
+        return formatReflectMap(val.field());
+      }
+      if (isReflectMessage(val)) {
+        return formatReflectMessage(val.desc);
+      }
+      if (isMessage(val)) {
+        return `message ${val.$typeName}`;
+      }
+      return "object";
+    case "string":
+      return val.length > 30 ? "string" : `"${val.split('"').join("\\\"")}"`;
+    case "boolean":
+      return String(val);
+    case "number":
+      return String(val);
+    case "bigint":
+      return String(val) + "n";
+    default:
+      return typeof val;
+  }
+}
+function formatReflectMessage(desc) {
+  return `ReflectMessage (${desc.typeName})`;
+}
+function formatReflectList(field) {
+  switch (field.listKind) {
+    case "message":
+      return `ReflectList (${field.message.toString()})`;
+    case "enum":
+      return `ReflectList (${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectList (${ScalarType[field.scalar]})`;
+  }
+}
+function formatReflectMap(field) {
+  switch (field.mapKind) {
+    case "message":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.message.toString()})`;
+    case "enum":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`;
+  }
+}
+function scalarTypeDescription(scalar) {
+  switch (scalar) {
+    case ScalarType.STRING:
+      return "string";
+    case ScalarType.BOOL:
+      return "boolean";
+    case ScalarType.INT64:
+    case ScalarType.SINT64:
+    case ScalarType.SFIXED64:
+      return "bigint (int64)";
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return "bigint (uint64)";
+    case ScalarType.BYTES:
+      return "Uint8Array";
+    case ScalarType.DOUBLE:
+      return "number (float64)";
+    case ScalarType.FLOAT:
+      return "number (float32)";
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      return "number (uint32)";
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      return "number (int32)";
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/wrappers.js
+function isWrapper(arg) {
+  return isWrapperTypeName(arg.$typeName);
+}
+function isWrapperDesc(messageDesc) {
+  const f = messageDesc.fields[0];
+  return isWrapperTypeName(messageDesc.typeName) && f !== undefined && f.fieldKind == "scalar" && f.name == "value" && f.number == 1;
+}
+function isWrapperTypeName(name) {
+  return name.startsWith("google.protobuf.") && [
+    "DoubleValue",
+    "FloatValue",
+    "Int64Value",
+    "UInt64Value",
+    "Int32Value",
+    "UInt32Value",
+    "BoolValue",
+    "StringValue",
+    "BytesValue"
+  ].includes(name.substring(16));
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/create.js
+var EDITION_PROTO32 = 999;
+var EDITION_PROTO22 = 998;
+var IMPLICIT3 = 2;
+function create(schema, init) {
+  if (isMessage(init, schema)) {
+    return init;
+  }
+  const message = createZeroMessage(schema);
+  if (init !== undefined) {
+    initMessage(schema, message, init);
+  }
+  return message;
+}
+function initMessage(messageDesc, message, init) {
+  for (const member of messageDesc.members) {
+    let value = init[member.localName];
+    if (value == null) {
+      continue;
+    }
+    let field;
+    if (member.kind == "oneof") {
+      const oneofField = unsafeOneofCase(init, member);
+      if (!oneofField) {
+        continue;
+      }
+      field = oneofField;
+      value = unsafeGet(init, oneofField);
+    } else {
+      field = member;
+    }
+    switch (field.fieldKind) {
+      case "message":
+        value = toMessage(field, value);
+        break;
+      case "scalar":
+        value = initScalar(field, value);
+        break;
+      case "list":
+        value = initList(field, value);
+        break;
+      case "map":
+        value = initMap(field, value);
+        break;
+    }
+    unsafeSet(message, field, value);
+  }
+  return message;
+}
+function initScalar(field, value) {
+  if (field.scalar == ScalarType.BYTES) {
+    return toU8Arr(value);
+  }
+  return value;
+}
+function initMap(field, value) {
+  if (isObject(value)) {
+    if (field.scalar == ScalarType.BYTES) {
+      return convertObjectValues(value, toU8Arr);
+    }
+    if (field.mapKind == "message") {
+      return convertObjectValues(value, (val) => toMessage(field, val));
+    }
+  }
+  return value;
+}
+function initList(field, value) {
+  if (Array.isArray(value)) {
+    if (field.scalar == ScalarType.BYTES) {
+      return value.map(toU8Arr);
+    }
+    if (field.listKind == "message") {
+      return value.map((item) => toMessage(field, item));
+    }
+  }
+  return value;
+}
+function toMessage(field, value) {
+  if (field.fieldKind == "message" && !field.oneof && isWrapperDesc(field.message)) {
+    return initScalar(field.message.fields[0], value);
+  }
+  if (isObject(value)) {
+    if (field.message.typeName == "google.protobuf.Struct" && field.parent.typeName !== "google.protobuf.Value") {
+      return value;
+    }
+    if (!isMessage(value, field.message)) {
+      return create(field.message, value);
+    }
+  }
+  return value;
+}
+function toU8Arr(value) {
+  return Array.isArray(value) ? new Uint8Array(value) : value;
+}
+function convertObjectValues(obj, fn) {
+  const ret = {};
+  for (const entry of Object.entries(obj)) {
+    ret[entry[0]] = fn(entry[1]);
+  }
+  return ret;
+}
+var tokenZeroMessageField = Symbol();
+var messagePrototypes = new WeakMap;
+function createZeroMessage(desc) {
+  let msg;
+  if (!needsPrototypeChain(desc)) {
+    msg = {
+      $typeName: desc.typeName
+    };
+    for (const member of desc.members) {
+      if (member.kind == "oneof" || member.presence == IMPLICIT3) {
+        msg[member.localName] = createZeroField(member);
+      }
+    }
+  } else {
+    const cached = messagePrototypes.get(desc);
+    let prototype;
+    let members;
+    if (cached) {
+      ({ prototype, members } = cached);
+    } else {
+      prototype = {};
+      members = new Set;
+      for (const member of desc.members) {
+        if (member.kind == "oneof") {
+          continue;
+        }
+        if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
+          continue;
+        }
+        if (member.presence == IMPLICIT3) {
+          continue;
+        }
+        members.add(member);
+        prototype[member.localName] = createZeroField(member);
+      }
+      messagePrototypes.set(desc, { prototype, members });
+    }
+    msg = Object.create(prototype);
+    msg.$typeName = desc.typeName;
+    for (const member of desc.members) {
+      if (members.has(member)) {
+        continue;
+      }
+      if (member.kind == "field") {
+        if (member.fieldKind == "message") {
+          continue;
+        }
+        if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
+          if (member.presence != IMPLICIT3) {
+            continue;
+          }
+        }
+      }
+      msg[member.localName] = createZeroField(member);
+    }
+  }
+  return msg;
+}
+function needsPrototypeChain(desc) {
+  switch (desc.file.edition) {
+    case EDITION_PROTO32:
+      return false;
+    case EDITION_PROTO22:
+      return true;
+    default:
+      return desc.fields.some((f) => f.presence != IMPLICIT3 && f.fieldKind != "message" && !f.oneof);
+  }
+}
+function createZeroField(field) {
+  if (field.kind == "oneof") {
+    return { case: undefined };
+  }
+  if (field.fieldKind == "list") {
+    return [];
+  }
+  if (field.fieldKind == "map") {
+    return {};
+  }
+  if (field.fieldKind == "message") {
+    return tokenZeroMessageField;
+  }
+  const defaultValue = field.getDefaultValue();
+  if (defaultValue !== undefined) {
+    return field.fieldKind == "scalar" && field.longAsString ? defaultValue.toString() : defaultValue;
+  }
+  return field.fieldKind == "scalar" ? scalarZeroValue(field.scalar, field.longAsString) : field.enum.values[0].number;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js
+function reflect(messageDesc, message, check = true) {
+  return new ReflectMessageImpl(messageDesc, message, check);
+}
+var messageSortedFields = new WeakMap;
+
+class ReflectMessageImpl {
+  get sortedFields() {
+    const cached = messageSortedFields.get(this.desc);
+    if (cached) {
+      return cached;
+    }
+    const sortedFields = this.desc.fields.concat().sort((a, b) => a.number - b.number);
+    messageSortedFields.set(this.desc, sortedFields);
+    return sortedFields;
+  }
+  constructor(messageDesc, message, check = true) {
+    this.lists = new Map;
+    this.maps = new Map;
+    this.check = check;
+    this.desc = messageDesc;
+    this.message = this[unsafeLocal] = message !== null && message !== undefined ? message : create(messageDesc);
+    this.fields = messageDesc.fields;
+    this.oneofs = messageDesc.oneofs;
+    this.members = messageDesc.members;
+  }
+  findNumber(number) {
+    if (!this._fieldsByNumber) {
+      this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+    }
+    return this._fieldsByNumber.get(number);
+  }
+  oneofCase(oneof) {
+    assertOwn(this.message, oneof);
+    return unsafeOneofCase(this.message, oneof);
+  }
+  isSet(field) {
+    assertOwn(this.message, field);
+    return unsafeIsSet(this.message, field);
+  }
+  clear(field) {
+    assertOwn(this.message, field);
+    unsafeClear(this.message, field);
+  }
+  get(field) {
+    assertOwn(this.message, field);
+    const value = unsafeGet(this.message, field);
+    switch (field.fieldKind) {
+      case "list":
+        let list = this.lists.get(field);
+        if (!list || list[unsafeLocal] !== value) {
+          this.lists.set(field, list = new ReflectListImpl(field, value, this.check));
+        }
+        return list;
+      case "map":
+        let map = this.maps.get(field);
+        if (!map || map[unsafeLocal] !== value) {
+          this.maps.set(field, map = new ReflectMapImpl(field, value, this.check));
+        }
+        return map;
+      case "message":
+        return messageToReflect(field, value, this.check);
+      case "scalar":
+        return value === undefined ? scalarZeroValue(field.scalar, false) : longToReflect(field, value);
+      case "enum":
+        return value !== null && value !== undefined ? value : field.enum.values[0].number;
+    }
+  }
+  set(field, value) {
+    assertOwn(this.message, field);
+    if (this.check) {
+      const err = checkField(field, value);
+      if (err) {
+        throw err;
+      }
+    }
+    let local;
+    if (field.fieldKind == "message") {
+      local = messageToLocal(field, value);
+    } else if (isReflectMap(value) || isReflectList(value)) {
+      local = value[unsafeLocal];
+    } else {
+      local = longToLocal(field, value);
+    }
+    unsafeSet(this.message, field, local);
+  }
+  getUnknown() {
+    return this.message.$unknown;
+  }
+  setUnknown(value) {
+    this.message.$unknown = value;
+  }
+}
+function assertOwn(owner, member) {
+  if (member.parent.typeName !== owner.$typeName) {
+    throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+  }
+}
+class ReflectListImpl {
+  field() {
+    return this._field;
+  }
+  get size() {
+    return this._arr.length;
+  }
+  constructor(field, unsafeInput, check) {
+    this._field = field;
+    this._arr = this[unsafeLocal] = unsafeInput;
+    this.check = check;
+  }
+  get(index) {
+    const item = this._arr[index];
+    return item === undefined ? undefined : listItemToReflect(this._field, item, this.check);
+  }
+  set(index, item) {
+    if (index < 0 || index >= this._arr.length) {
+      throw new FieldError(this._field, `list item #${index + 1}: out of range`);
+    }
+    if (this.check) {
+      const err = checkListItem(this._field, index, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr[index] = listItemToLocal(this._field, item);
+  }
+  add(item) {
+    if (this.check) {
+      const err = checkListItem(this._field, this._arr.length, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr.push(listItemToLocal(this._field, item));
+    return;
+  }
+  clear() {
+    this._arr.splice(0, this._arr.length);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  keys() {
+    return this._arr.keys();
+  }
+  *values() {
+    for (const item of this._arr) {
+      yield listItemToReflect(this._field, item, this.check);
+    }
+  }
+  *entries() {
+    for (let i = 0;i < this._arr.length; i++) {
+      yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+    }
+  }
+}
+class ReflectMapImpl {
+  constructor(field, unsafeInput, check = true) {
+    this.obj = this[unsafeLocal] = unsafeInput !== null && unsafeInput !== undefined ? unsafeInput : {};
+    this.check = check;
+    this._field = field;
+  }
+  field() {
+    return this._field;
+  }
+  set(key, value) {
+    if (this.check) {
+      const err = checkMapEntry(this._field, key, value);
+      if (err) {
+        throw err;
+      }
+    }
+    this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+    return this;
+  }
+  delete(key) {
+    const k = mapKeyToLocal(key);
+    const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+    if (has) {
+      delete this.obj[k];
+    }
+    return has;
+  }
+  clear() {
+    for (const key of Object.keys(this.obj)) {
+      delete this.obj[key];
+    }
+  }
+  get(key) {
+    let val = this.obj[mapKeyToLocal(key)];
+    if (val !== undefined) {
+      val = mapValueToReflect(this._field, val, this.check);
+    }
+    return val;
+  }
+  has(key) {
+    return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+  }
+  *keys() {
+    for (const objKey of Object.keys(this.obj)) {
+      yield mapKeyToReflect(objKey, this._field.mapKey);
+    }
+  }
+  *entries() {
+    for (const objEntry of Object.entries(this.obj)) {
+      yield [
+        mapKeyToReflect(objEntry[0], this._field.mapKey),
+        mapValueToReflect(this._field, objEntry[1], this.check)
+      ];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return Object.keys(this.obj).length;
+  }
+  *values() {
+    for (const val of Object.values(this.obj)) {
+      yield mapValueToReflect(this._field, val, this.check);
+    }
+  }
+  forEach(callbackfn, thisArg) {
+    for (const mapEntry of this.entries()) {
+      callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+    }
+  }
+}
+function messageToLocal(field, value) {
+  if (!isReflectMessage(value)) {
+    return value;
+  }
+  if (isWrapper(value.message) && !field.oneof && field.fieldKind == "message") {
+    return value.message.value;
+  }
+  if (value.desc.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value") {
+    return wktStructToLocal(value.message);
+  }
+  return value.message;
+}
+function messageToReflect(field, value, check) {
+  if (value !== undefined) {
+    if (isWrapperDesc(field.message) && !field.oneof && field.fieldKind == "message") {
+      value = {
+        $typeName: field.message.typeName,
+        value: longToReflect(field.message.fields[0], value)
+      };
+    } else if (field.message.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value" && isObject(value)) {
+      value = wktStructToReflect(value);
+    }
+  }
+  return new ReflectMessageImpl(field.message, value, check);
+}
+function listItemToLocal(field, value) {
+  if (field.listKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function listItemToReflect(field, value, check) {
+  if (field.listKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+  if (field.mapKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function mapValueToReflect(field, value, check) {
+  if (field.mapKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return value;
+}
+function mapKeyToLocal(key) {
+  return typeof key == "string" || typeof key == "number" ? key : String(key);
+}
+function mapKeyToReflect(key, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return key;
+    case ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32: {
+      const n = Number.parseInt(key);
+      if (Number.isFinite(n)) {
+        return n;
+      }
+      break;
+    }
+    case ScalarType.BOOL:
+      switch (key) {
+        case "true":
+          return true;
+        case "false":
+          return false;
+      }
+      break;
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      try {
+        return protoInt64.uParse(key);
+      } catch (_a) {}
+      break;
+    default:
+      try {
+        return protoInt64.parse(key);
+      } catch (_b) {}
+      break;
+  }
+  return key;
+}
+function longToReflect(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function longToLocal(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function wktStructToReflect(json) {
+  const struct = {
+    $typeName: "google.protobuf.Struct",
+    fields: {}
+  };
+  if (isObject(json)) {
+    for (const [k, v] of Object.entries(json)) {
+      struct.fields[k] = wktValueToReflect(v);
+    }
+  }
+  return struct;
+}
+function wktStructToLocal(val) {
+  const json = {};
+  for (const [k, v] of Object.entries(val.fields)) {
+    json[k] = wktValueToLocal(v);
+  }
+  return json;
+}
+function wktValueToLocal(val) {
+  switch (val.kind.case) {
+    case "structValue":
+      return wktStructToLocal(val.kind.value);
+    case "listValue":
+      return val.kind.value.values.map(wktValueToLocal);
+    case "nullValue":
+    case undefined:
+      return null;
+    default:
+      return val.kind.value;
+  }
+}
+function wktValueToReflect(json) {
+  const value = {
+    $typeName: "google.protobuf.Value",
+    kind: { case: undefined }
+  };
+  switch (typeof json) {
+    case "number":
+      value.kind = { case: "numberValue", value: json };
+      break;
+    case "string":
+      value.kind = { case: "stringValue", value: json };
+      break;
+    case "boolean":
+      value.kind = { case: "boolValue", value: json };
+      break;
+    case "object":
+      if (json === null) {
+        const nullValue = 0;
+        value.kind = { case: "nullValue", value: nullValue };
+      } else if (Array.isArray(json)) {
+        const listValue = {
+          $typeName: "google.protobuf.ListValue",
+          values: []
+        };
+        if (Array.isArray(json)) {
+          for (const e of json) {
+            listValue.values.push(wktValueToReflect(e));
+          }
+        }
+        value.kind = {
+          case: "listValue",
+          value: listValue
+        };
+      } else {
+        value.kind = {
+          case: "structValue",
+          value: wktStructToReflect(json)
+        };
+      }
+      break;
+  }
+  return value;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js
+function messageDesc(file, path, ...paths) {
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.js
+function enumDesc(file, path, ...paths) {
+  if (paths.length == 0) {
+    return file.enums[path];
+  }
+  const e = paths.pop();
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js
+var file_google_protobuf_descriptor = /* @__PURE__ */ boot({ name: "google/protobuf/descriptor.proto", package: "google.protobuf", messageType: [{ name: "FileDescriptorSet", field: [{ name: "file", number: 1, type: 11, label: 3, typeName: ".google.protobuf.FileDescriptorProto" }], extensionRange: [{ start: 536000000, end: 536000001 }] }, { name: "FileDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "package", number: 2, type: 9, label: 1 }, { name: "dependency", number: 3, type: 9, label: 3 }, { name: "public_dependency", number: 10, type: 5, label: 3 }, { name: "weak_dependency", number: 11, type: 5, label: 3 }, { name: "option_dependency", number: 15, type: 9, label: 3 }, { name: "message_type", number: 4, type: 11, label: 3, typeName: ".google.protobuf.DescriptorProto" }, { name: "enum_type", number: 5, type: 11, label: 3, typeName: ".google.protobuf.EnumDescriptorProto" }, { name: "service", number: 6, type: 11, label: 3, typeName: ".google.protobuf.ServiceDescriptorProto" }, { name: "extension", number: 7, type: 11, label: 3, typeName: ".google.protobuf.FieldDescriptorProto" }, { name: "options", number: 8, type: 11, label: 1, typeName: ".google.protobuf.FileOptions" }, { name: "source_code_info", number: 9, type: 11, label: 1, typeName: ".google.protobuf.SourceCodeInfo" }, { name: "syntax", number: 12, type: 9, label: 1 }, { name: "edition", number: 14, type: 14, label: 1, typeName: ".google.protobuf.Edition" }] }, { name: "DescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "field", number: 2, type: 11, label: 3, typeName: ".google.protobuf.FieldDescriptorProto" }, { name: "extension", number: 6, type: 11, label: 3, typeName: ".google.protobuf.FieldDescriptorProto" }, { name: "nested_type", number: 3, type: 11, label: 3, typeName: ".google.protobuf.DescriptorProto" }, { name: "enum_type", number: 4, type: 11, label: 3, typeName: ".google.protobuf.EnumDescriptorProto" }, { name: "extension_range", number: 5, type: 11, label: 3, typeName: ".google.protobuf.DescriptorProto.ExtensionRange" }, { name: "oneof_decl", number: 8, type: 11, label: 3, typeName: ".google.protobuf.OneofDescriptorProto" }, { name: "options", number: 7, type: 11, label: 1, typeName: ".google.protobuf.MessageOptions" }, { name: "reserved_range", number: 9, type: 11, label: 3, typeName: ".google.protobuf.DescriptorProto.ReservedRange" }, { name: "reserved_name", number: 10, type: 9, label: 3 }, { name: "visibility", number: 11, type: 14, label: 1, typeName: ".google.protobuf.SymbolVisibility" }], nestedType: [{ name: "ExtensionRange", field: [{ name: "start", number: 1, type: 5, label: 1 }, { name: "end", number: 2, type: 5, label: 1 }, { name: "options", number: 3, type: 11, label: 1, typeName: ".google.protobuf.ExtensionRangeOptions" }] }, { name: "ReservedRange", field: [{ name: "start", number: 1, type: 5, label: 1 }, { name: "end", number: 2, type: 5, label: 1 }] }] }, { name: "ExtensionRangeOptions", field: [{ name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }, { name: "declaration", number: 2, type: 11, label: 3, typeName: ".google.protobuf.ExtensionRangeOptions.Declaration", options: { retention: 2 } }, { name: "features", number: 50, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "verification", number: 3, type: 14, label: 1, typeName: ".google.protobuf.ExtensionRangeOptions.VerificationState", defaultValue: "UNVERIFIED", options: { retention: 2 } }], nestedType: [{ name: "Declaration", field: [{ name: "number", number: 1, type: 5, label: 1 }, { name: "full_name", number: 2, type: 9, label: 1 }, { name: "type", number: 3, type: 9, label: 1 }, { name: "reserved", number: 5, type: 8, label: 1 }, { name: "repeated", number: 6, type: 8, label: 1 }] }], enumType: [{ name: "VerificationState", value: [{ name: "DECLARATION", number: 0 }, { name: "UNVERIFIED", number: 1 }] }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "FieldDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "number", number: 3, type: 5, label: 1 }, { name: "label", number: 4, type: 14, label: 1, typeName: ".google.protobuf.FieldDescriptorProto.Label" }, { name: "type", number: 5, type: 14, label: 1, typeName: ".google.protobuf.FieldDescriptorProto.Type" }, { name: "type_name", number: 6, type: 9, label: 1 }, { name: "extendee", number: 2, type: 9, label: 1 }, { name: "default_value", number: 7, type: 9, label: 1 }, { name: "oneof_index", number: 9, type: 5, label: 1 }, { name: "json_name", number: 10, type: 9, label: 1 }, { name: "options", number: 8, type: 11, label: 1, typeName: ".google.protobuf.FieldOptions" }, { name: "proto3_optional", number: 17, type: 8, label: 1 }], enumType: [{ name: "Type", value: [{ name: "TYPE_DOUBLE", number: 1 }, { name: "TYPE_FLOAT", number: 2 }, { name: "TYPE_INT64", number: 3 }, { name: "TYPE_UINT64", number: 4 }, { name: "TYPE_INT32", number: 5 }, { name: "TYPE_FIXED64", number: 6 }, { name: "TYPE_FIXED32", number: 7 }, { name: "TYPE_BOOL", number: 8 }, { name: "TYPE_STRING", number: 9 }, { name: "TYPE_GROUP", number: 10 }, { name: "TYPE_MESSAGE", number: 11 }, { name: "TYPE_BYTES", number: 12 }, { name: "TYPE_UINT32", number: 13 }, { name: "TYPE_ENUM", number: 14 }, { name: "TYPE_SFIXED32", number: 15 }, { name: "TYPE_SFIXED64", number: 16 }, { name: "TYPE_SINT32", number: 17 }, { name: "TYPE_SINT64", number: 18 }] }, { name: "Label", value: [{ name: "LABEL_OPTIONAL", number: 1 }, { name: "LABEL_REPEATED", number: 3 }, { name: "LABEL_REQUIRED", number: 2 }] }] }, { name: "OneofDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "options", number: 2, type: 11, label: 1, typeName: ".google.protobuf.OneofOptions" }] }, { name: "EnumDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "value", number: 2, type: 11, label: 3, typeName: ".google.protobuf.EnumValueDescriptorProto" }, { name: "options", number: 3, type: 11, label: 1, typeName: ".google.protobuf.EnumOptions" }, { name: "reserved_range", number: 4, type: 11, label: 3, typeName: ".google.protobuf.EnumDescriptorProto.EnumReservedRange" }, { name: "reserved_name", number: 5, type: 9, label: 3 }, { name: "visibility", number: 6, type: 14, label: 1, typeName: ".google.protobuf.SymbolVisibility" }], nestedType: [{ name: "EnumReservedRange", field: [{ name: "start", number: 1, type: 5, label: 1 }, { name: "end", number: 2, type: 5, label: 1 }] }] }, { name: "EnumValueDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "number", number: 2, type: 5, label: 1 }, { name: "options", number: 3, type: 11, label: 1, typeName: ".google.protobuf.EnumValueOptions" }] }, { name: "ServiceDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "method", number: 2, type: 11, label: 3, typeName: ".google.protobuf.MethodDescriptorProto" }, { name: "options", number: 3, type: 11, label: 1, typeName: ".google.protobuf.ServiceOptions" }] }, { name: "MethodDescriptorProto", field: [{ name: "name", number: 1, type: 9, label: 1 }, { name: "input_type", number: 2, type: 9, label: 1 }, { name: "output_type", number: 3, type: 9, label: 1 }, { name: "options", number: 4, type: 11, label: 1, typeName: ".google.protobuf.MethodOptions" }, { name: "client_streaming", number: 5, type: 8, label: 1, defaultValue: "false" }, { name: "server_streaming", number: 6, type: 8, label: 1, defaultValue: "false" }] }, { name: "FileOptions", field: [{ name: "java_package", number: 1, type: 9, label: 1 }, { name: "java_outer_classname", number: 8, type: 9, label: 1 }, { name: "java_multiple_files", number: 10, type: 8, label: 1, defaultValue: "false" }, { name: "java_generate_equals_and_hash", number: 20, type: 8, label: 1, options: { deprecated: true } }, { name: "java_string_check_utf8", number: 27, type: 8, label: 1, defaultValue: "false" }, { name: "optimize_for", number: 9, type: 14, label: 1, typeName: ".google.protobuf.FileOptions.OptimizeMode", defaultValue: "SPEED" }, { name: "go_package", number: 11, type: 9, label: 1 }, { name: "cc_generic_services", number: 16, type: 8, label: 1, defaultValue: "false" }, { name: "java_generic_services", number: 17, type: 8, label: 1, defaultValue: "false" }, { name: "py_generic_services", number: 18, type: 8, label: 1, defaultValue: "false" }, { name: "deprecated", number: 23, type: 8, label: 1, defaultValue: "false" }, { name: "cc_enable_arenas", number: 31, type: 8, label: 1, defaultValue: "true" }, { name: "objc_class_prefix", number: 36, type: 9, label: 1 }, { name: "csharp_namespace", number: 37, type: 9, label: 1 }, { name: "swift_prefix", number: 39, type: 9, label: 1 }, { name: "php_class_prefix", number: 40, type: 9, label: 1 }, { name: "php_namespace", number: 41, type: 9, label: 1 }, { name: "php_metadata_namespace", number: 44, type: 9, label: 1 }, { name: "ruby_package", number: 45, type: 9, label: 1 }, { name: "features", number: 50, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], enumType: [{ name: "OptimizeMode", value: [{ name: "SPEED", number: 1 }, { name: "CODE_SIZE", number: 2 }, { name: "LITE_RUNTIME", number: 3 }] }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "MessageOptions", field: [{ name: "message_set_wire_format", number: 1, type: 8, label: 1, defaultValue: "false" }, { name: "no_standard_descriptor_accessor", number: 2, type: 8, label: 1, defaultValue: "false" }, { name: "deprecated", number: 3, type: 8, label: 1, defaultValue: "false" }, { name: "map_entry", number: 7, type: 8, label: 1 }, { name: "deprecated_legacy_json_field_conflicts", number: 11, type: 8, label: 1, options: { deprecated: true } }, { name: "features", number: 12, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "FieldOptions", field: [{ name: "ctype", number: 1, type: 14, label: 1, typeName: ".google.protobuf.FieldOptions.CType", defaultValue: "STRING" }, { name: "packed", number: 2, type: 8, label: 1 }, { name: "jstype", number: 6, type: 14, label: 1, typeName: ".google.protobuf.FieldOptions.JSType", defaultValue: "JS_NORMAL" }, { name: "lazy", number: 5, type: 8, label: 1, defaultValue: "false" }, { name: "unverified_lazy", number: 15, type: 8, label: 1, defaultValue: "false" }, { name: "deprecated", number: 3, type: 8, label: 1, defaultValue: "false" }, { name: "weak", number: 10, type: 8, label: 1, defaultValue: "false", options: { deprecated: true } }, { name: "debug_redact", number: 16, type: 8, label: 1, defaultValue: "false" }, { name: "retention", number: 17, type: 14, label: 1, typeName: ".google.protobuf.FieldOptions.OptionRetention" }, { name: "targets", number: 19, type: 14, label: 3, typeName: ".google.protobuf.FieldOptions.OptionTargetType" }, { name: "edition_defaults", number: 20, type: 11, label: 3, typeName: ".google.protobuf.FieldOptions.EditionDefault" }, { name: "features", number: 21, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "feature_support", number: 22, type: 11, label: 1, typeName: ".google.protobuf.FieldOptions.FeatureSupport" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], nestedType: [{ name: "EditionDefault", field: [{ name: "edition", number: 3, type: 14, label: 1, typeName: ".google.protobuf.Edition" }, { name: "value", number: 2, type: 9, label: 1 }] }, { name: "FeatureSupport", field: [{ name: "edition_introduced", number: 1, type: 14, label: 1, typeName: ".google.protobuf.Edition" }, { name: "edition_deprecated", number: 2, type: 14, label: 1, typeName: ".google.protobuf.Edition" }, { name: "deprecation_warning", number: 3, type: 9, label: 1 }, { name: "edition_removed", number: 4, type: 14, label: 1, typeName: ".google.protobuf.Edition" }] }], enumType: [{ name: "CType", value: [{ name: "STRING", number: 0 }, { name: "CORD", number: 1 }, { name: "STRING_PIECE", number: 2 }] }, { name: "JSType", value: [{ name: "JS_NORMAL", number: 0 }, { name: "JS_STRING", number: 1 }, { name: "JS_NUMBER", number: 2 }] }, { name: "OptionRetention", value: [{ name: "RETENTION_UNKNOWN", number: 0 }, { name: "RETENTION_RUNTIME", number: 1 }, { name: "RETENTION_SOURCE", number: 2 }] }, { name: "OptionTargetType", value: [{ name: "TARGET_TYPE_UNKNOWN", number: 0 }, { name: "TARGET_TYPE_FILE", number: 1 }, { name: "TARGET_TYPE_EXTENSION_RANGE", number: 2 }, { name: "TARGET_TYPE_MESSAGE", number: 3 }, { name: "TARGET_TYPE_FIELD", number: 4 }, { name: "TARGET_TYPE_ONEOF", number: 5 }, { name: "TARGET_TYPE_ENUM", number: 6 }, { name: "TARGET_TYPE_ENUM_ENTRY", number: 7 }, { name: "TARGET_TYPE_SERVICE", number: 8 }, { name: "TARGET_TYPE_METHOD", number: 9 }] }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "OneofOptions", field: [{ name: "features", number: 1, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "EnumOptions", field: [{ name: "allow_alias", number: 2, type: 8, label: 1 }, { name: "deprecated", number: 3, type: 8, label: 1, defaultValue: "false" }, { name: "deprecated_legacy_json_field_conflicts", number: 6, type: 8, label: 1, options: { deprecated: true } }, { name: "features", number: 7, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "EnumValueOptions", field: [{ name: "deprecated", number: 1, type: 8, label: 1, defaultValue: "false" }, { name: "features", number: 2, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "debug_redact", number: 3, type: 8, label: 1, defaultValue: "false" }, { name: "feature_support", number: 4, type: 11, label: 1, typeName: ".google.protobuf.FieldOptions.FeatureSupport" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "ServiceOptions", field: [{ name: "features", number: 34, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "deprecated", number: 33, type: 8, label: 1, defaultValue: "false" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "MethodOptions", field: [{ name: "deprecated", number: 33, type: 8, label: 1, defaultValue: "false" }, { name: "idempotency_level", number: 34, type: 14, label: 1, typeName: ".google.protobuf.MethodOptions.IdempotencyLevel", defaultValue: "IDEMPOTENCY_UNKNOWN" }, { name: "features", number: 35, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "uninterpreted_option", number: 999, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption" }], enumType: [{ name: "IdempotencyLevel", value: [{ name: "IDEMPOTENCY_UNKNOWN", number: 0 }, { name: "NO_SIDE_EFFECTS", number: 1 }, { name: "IDEMPOTENT", number: 2 }] }], extensionRange: [{ start: 1000, end: 536870912 }] }, { name: "UninterpretedOption", field: [{ name: "name", number: 2, type: 11, label: 3, typeName: ".google.protobuf.UninterpretedOption.NamePart" }, { name: "identifier_value", number: 3, type: 9, label: 1 }, { name: "positive_int_value", number: 4, type: 4, label: 1 }, { name: "negative_int_value", number: 5, type: 3, label: 1 }, { name: "double_value", number: 6, type: 1, label: 1 }, { name: "string_value", number: 7, type: 12, label: 1 }, { name: "aggregate_value", number: 8, type: 9, label: 1 }], nestedType: [{ name: "NamePart", field: [{ name: "name_part", number: 1, type: 9, label: 2 }, { name: "is_extension", number: 2, type: 8, label: 2 }] }] }, { name: "FeatureSet", field: [{ name: "field_presence", number: 1, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.FieldPresence", options: { retention: 1, targets: [4, 1], editionDefaults: [{ value: "EXPLICIT", edition: 900 }, { value: "IMPLICIT", edition: 999 }, { value: "EXPLICIT", edition: 1000 }] } }, { name: "enum_type", number: 2, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.EnumType", options: { retention: 1, targets: [6, 1], editionDefaults: [{ value: "CLOSED", edition: 900 }, { value: "OPEN", edition: 999 }] } }, { name: "repeated_field_encoding", number: 3, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.RepeatedFieldEncoding", options: { retention: 1, targets: [4, 1], editionDefaults: [{ value: "EXPANDED", edition: 900 }, { value: "PACKED", edition: 999 }] } }, { name: "utf8_validation", number: 4, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.Utf8Validation", options: { retention: 1, targets: [4, 1], editionDefaults: [{ value: "NONE", edition: 900 }, { value: "VERIFY", edition: 999 }] } }, { name: "message_encoding", number: 5, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.MessageEncoding", options: { retention: 1, targets: [4, 1], editionDefaults: [{ value: "LENGTH_PREFIXED", edition: 900 }] } }, { name: "json_format", number: 6, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.JsonFormat", options: { retention: 1, targets: [3, 6, 1], editionDefaults: [{ value: "LEGACY_BEST_EFFORT", edition: 900 }, { value: "ALLOW", edition: 999 }] } }, { name: "enforce_naming_style", number: 7, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.EnforceNamingStyle", options: { retention: 2, targets: [1, 2, 3, 4, 5, 6, 7, 8, 9], editionDefaults: [{ value: "STYLE_LEGACY", edition: 900 }, { value: "STYLE2024", edition: 1001 }] } }, { name: "default_symbol_visibility", number: 8, type: 14, label: 1, typeName: ".google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility", options: { retention: 2, targets: [1], editionDefaults: [{ value: "EXPORT_ALL", edition: 900 }, { value: "EXPORT_TOP_LEVEL", edition: 1001 }] } }], nestedType: [{ name: "VisibilityFeature", enumType: [{ name: "DefaultSymbolVisibility", value: [{ name: "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN", number: 0 }, { name: "EXPORT_ALL", number: 1 }, { name: "EXPORT_TOP_LEVEL", number: 2 }, { name: "LOCAL_ALL", number: 3 }, { name: "STRICT", number: 4 }] }] }], enumType: [{ name: "FieldPresence", value: [{ name: "FIELD_PRESENCE_UNKNOWN", number: 0 }, { name: "EXPLICIT", number: 1 }, { name: "IMPLICIT", number: 2 }, { name: "LEGACY_REQUIRED", number: 3 }] }, { name: "EnumType", value: [{ name: "ENUM_TYPE_UNKNOWN", number: 0 }, { name: "OPEN", number: 1 }, { name: "CLOSED", number: 2 }] }, { name: "RepeatedFieldEncoding", value: [{ name: "REPEATED_FIELD_ENCODING_UNKNOWN", number: 0 }, { name: "PACKED", number: 1 }, { name: "EXPANDED", number: 2 }] }, { name: "Utf8Validation", value: [{ name: "UTF8_VALIDATION_UNKNOWN", number: 0 }, { name: "VERIFY", number: 2 }, { name: "NONE", number: 3 }] }, { name: "MessageEncoding", value: [{ name: "MESSAGE_ENCODING_UNKNOWN", number: 0 }, { name: "LENGTH_PREFIXED", number: 1 }, { name: "DELIMITED", number: 2 }] }, { name: "JsonFormat", value: [{ name: "JSON_FORMAT_UNKNOWN", number: 0 }, { name: "ALLOW", number: 1 }, { name: "LEGACY_BEST_EFFORT", number: 2 }] }, { name: "EnforceNamingStyle", value: [{ name: "ENFORCE_NAMING_STYLE_UNKNOWN", number: 0 }, { name: "STYLE2024", number: 1 }, { name: "STYLE_LEGACY", number: 2 }] }], extensionRange: [{ start: 1000, end: 9995 }, { start: 9995, end: 1e4 }, { start: 1e4, end: 10001 }] }, { name: "FeatureSetDefaults", field: [{ name: "defaults", number: 1, type: 11, label: 3, typeName: ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" }, { name: "minimum_edition", number: 4, type: 14, label: 1, typeName: ".google.protobuf.Edition" }, { name: "maximum_edition", number: 5, type: 14, label: 1, typeName: ".google.protobuf.Edition" }], nestedType: [{ name: "FeatureSetEditionDefault", field: [{ name: "edition", number: 3, type: 14, label: 1, typeName: ".google.protobuf.Edition" }, { name: "overridable_features", number: 4, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }, { name: "fixed_features", number: 5, type: 11, label: 1, typeName: ".google.protobuf.FeatureSet" }] }] }, { name: "SourceCodeInfo", field: [{ name: "location", number: 1, type: 11, label: 3, typeName: ".google.protobuf.SourceCodeInfo.Location" }], nestedType: [{ name: "Location", field: [{ name: "path", number: 1, type: 5, label: 3, options: { packed: true } }, { name: "span", number: 2, type: 5, label: 3, options: { packed: true } }, { name: "leading_comments", number: 3, type: 9, label: 1 }, { name: "trailing_comments", number: 4, type: 9, label: 1 }, { name: "leading_detached_comments", number: 6, type: 9, label: 3 }] }], extensionRange: [{ start: 536000000, end: 536000001 }] }, { name: "GeneratedCodeInfo", field: [{ name: "annotation", number: 1, type: 11, label: 3, typeName: ".google.protobuf.GeneratedCodeInfo.Annotation" }], nestedType: [{ name: "Annotation", field: [{ name: "path", number: 1, type: 5, label: 3, options: { packed: true } }, { name: "source_file", number: 2, type: 9, label: 1 }, { name: "begin", number: 3, type: 5, label: 1 }, { name: "end", number: 4, type: 5, label: 1 }, { name: "semantic", number: 5, type: 14, label: 1, typeName: ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic" }], enumType: [{ name: "Semantic", value: [{ name: "NONE", number: 0 }, { name: "SET", number: 1 }, { name: "ALIAS", number: 2 }] }] }] }], enumType: [{ name: "Edition", value: [{ name: "EDITION_UNKNOWN", number: 0 }, { name: "EDITION_LEGACY", number: 900 }, { name: "EDITION_PROTO2", number: 998 }, { name: "EDITION_PROTO3", number: 999 }, { name: "EDITION_2023", number: 1000 }, { name: "EDITION_2024", number: 1001 }, { name: "EDITION_UNSTABLE", number: 9999 }, { name: "EDITION_1_TEST_ONLY", number: 1 }, { name: "EDITION_2_TEST_ONLY", number: 2 }, { name: "EDITION_99997_TEST_ONLY", number: 99997 }, { name: "EDITION_99998_TEST_ONLY", number: 99998 }, { name: "EDITION_99999_TEST_ONLY", number: 99999 }, { name: "EDITION_MAX", number: 2147483647 }] }, { name: "SymbolVisibility", value: [{ name: "VISIBILITY_UNSET", number: 0 }, { name: "VISIBILITY_LOCAL", number: 1 }, { name: "VISIBILITY_EXPORT", number: 2 }] }] });
+var FileDescriptorProtoSchema = /* @__PURE__ */ messageDesc(file_google_protobuf_descriptor, 1);
+var ExtensionRangeOptions_VerificationState;
+(function(ExtensionRangeOptions_VerificationState2) {
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["DECLARATION"] = 0] = "DECLARATION";
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["UNVERIFIED"] = 1] = "UNVERIFIED";
+})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {}));
+var FieldDescriptorProto_Type;
+(function(FieldDescriptorProto_Type2) {
+  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";
+})(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {}));
+var FieldDescriptorProto_Label;
+(function(FieldDescriptorProto_Label2) {
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["OPTIONAL"] = 1] = "OPTIONAL";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REPEATED"] = 3] = "REPEATED";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REQUIRED"] = 2] = "REQUIRED";
+})(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
+var FileOptions_OptimizeMode;
+(function(FileOptions_OptimizeMode2) {
+  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";
+})(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {}));
+var FieldOptions_CType;
+(function(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";
+})(FieldOptions_CType || (FieldOptions_CType = {}));
+var FieldOptions_JSType;
+(function(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";
+})(FieldOptions_JSType || (FieldOptions_JSType = {}));
+var FieldOptions_OptionRetention;
+(function(FieldOptions_OptionRetention2) {
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE";
+})(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {}));
+var FieldOptions_OptionTargetType;
+(function(FieldOptions_OptionTargetType2) {
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD";
+})(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {}));
+var MethodOptions_IdempotencyLevel;
+(function(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";
+})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {}));
+var FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
+(function(FeatureSet_VisibilityFeature_DefaultSymbolVisibility2) {
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"] = 0] = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["EXPORT_ALL"] = 1] = "EXPORT_ALL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["EXPORT_TOP_LEVEL"] = 2] = "EXPORT_TOP_LEVEL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["LOCAL_ALL"] = 3] = "LOCAL_ALL";
+  FeatureSet_VisibilityFeature_DefaultSymbolVisibility2[FeatureSet_VisibilityFeature_DefaultSymbolVisibility2["STRICT"] = 4] = "STRICT";
+})(FeatureSet_VisibilityFeature_DefaultSymbolVisibility || (FeatureSet_VisibilityFeature_DefaultSymbolVisibility = {}));
+var FeatureSet_FieldPresence;
+(function(FeatureSet_FieldPresence2) {
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["EXPLICIT"] = 1] = "EXPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["IMPLICIT"] = 2] = "IMPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED";
+})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {}));
+var FeatureSet_EnumType;
+(function(FeatureSet_EnumType2) {
+  FeatureSet_EnumType2[FeatureSet_EnumType2["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["OPEN"] = 1] = "OPEN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["CLOSED"] = 2] = "CLOSED";
+})(FeatureSet_EnumType || (FeatureSet_EnumType = {}));
+var FeatureSet_RepeatedFieldEncoding;
+(function(FeatureSet_RepeatedFieldEncoding2) {
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["PACKED"] = 1] = "PACKED";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["EXPANDED"] = 2] = "EXPANDED";
+})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {}));
+var FeatureSet_Utf8Validation;
+(function(FeatureSet_Utf8Validation2) {
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["VERIFY"] = 2] = "VERIFY";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["NONE"] = 3] = "NONE";
+})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
+var FeatureSet_MessageEncoding;
+(function(FeatureSet_MessageEncoding2) {
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["DELIMITED"] = 2] = "DELIMITED";
+})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {}));
+var FeatureSet_JsonFormat;
+(function(FeatureSet_JsonFormat2) {
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["ALLOW"] = 1] = "ALLOW";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT";
+})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {}));
+var FeatureSet_EnforceNamingStyle;
+(function(FeatureSet_EnforceNamingStyle2) {
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE2024"] = 1] = "STYLE2024";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE_LEGACY"] = 2] = "STYLE_LEGACY";
+})(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {}));
+var GeneratedCodeInfo_Annotation_Semantic;
+(function(GeneratedCodeInfo_Annotation_Semantic2) {
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["NONE"] = 0] = "NONE";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["SET"] = 1] = "SET";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["ALIAS"] = 2] = "ALIAS";
+})(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {}));
+var Edition;
+(function(Edition2) {
+  Edition2[Edition2["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN";
+  Edition2[Edition2["EDITION_LEGACY"] = 900] = "EDITION_LEGACY";
+  Edition2[Edition2["EDITION_PROTO2"] = 998] = "EDITION_PROTO2";
+  Edition2[Edition2["EDITION_PROTO3"] = 999] = "EDITION_PROTO3";
+  Edition2[Edition2["EDITION_2023"] = 1000] = "EDITION_2023";
+  Edition2[Edition2["EDITION_2024"] = 1001] = "EDITION_2024";
+  Edition2[Edition2["EDITION_UNSTABLE"] = 9999] = "EDITION_UNSTABLE";
+  Edition2[Edition2["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY";
+  Edition2[Edition2["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY";
+  Edition2[Edition2["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY";
+  Edition2[Edition2["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY";
+  Edition2[Edition2["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
+  Edition2[Edition2["EDITION_MAX"] = 2147483647] = "EDITION_MAX";
+})(Edition || (Edition = {}));
+var SymbolVisibility;
+(function(SymbolVisibility2) {
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_UNSET"] = 0] = "VISIBILITY_UNSET";
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_LOCAL"] = 1] = "VISIBILITY_LOCAL";
+  SymbolVisibility2[SymbolVisibility2["VISIBILITY_EXPORT"] = 2] = "VISIBILITY_EXPORT";
+})(SymbolVisibility || (SymbolVisibility = {}));
+
+// node_modules/@bufbuild/protobuf/dist/esm/from-binary.js
+var readDefaults = {
+  readUnknownFields: true
+};
+function makeReadOptions(options) {
+  return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+}
+function fromBinary(schema, bytes, options) {
+  const msg = reflect(schema, undefined, false);
+  readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+  return msg.message;
+}
+function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+  var _a;
+  const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+  let fieldNo;
+  let wireType;
+  const unknownFields = (_a = message.getUnknown()) !== null && _a !== undefined ? _a : [];
+  while (reader.pos < end) {
+    [fieldNo, wireType] = reader.tag();
+    if (delimited && wireType == WireType.EndGroup) {
+      break;
+    }
+    const field = message.findNumber(fieldNo);
+    if (!field) {
+      const data = reader.skip(wireType, fieldNo);
+      if (options.readUnknownFields) {
+        unknownFields.push({ no: fieldNo, wireType, data });
+      }
+      continue;
+    }
+    readField(message, reader, field, wireType, options);
+  }
+  if (delimited) {
+    if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+      throw new Error("invalid end group tag");
+    }
+  }
+  if (unknownFields.length > 0) {
+    message.setUnknown(unknownFields);
+  }
+}
+function readField(message, reader, field, wireType, options) {
+  var _a;
+  switch (field.fieldKind) {
+    case "scalar":
+      message.set(field, readScalar(reader, field.scalar));
+      break;
+    case "enum":
+      const val = readScalar(reader, ScalarType.INT32);
+      if (field.enum.open) {
+        message.set(field, val);
+      } else {
+        const ok = field.enum.values.some((v) => v.number === val);
+        if (ok) {
+          message.set(field, val);
+        } else if (options.readUnknownFields) {
+          const bytes = [];
+          varint32write(val, bytes);
+          const unknownFields = (_a = message.getUnknown()) !== null && _a !== undefined ? _a : [];
+          unknownFields.push({
+            no: field.number,
+            wireType,
+            data: new Uint8Array(bytes)
+          });
+          message.setUnknown(unknownFields);
+        }
+      }
+      break;
+    case "message":
+      message.set(field, readMessageField(reader, options, field, message.get(field)));
+      break;
+    case "list":
+      readListField(reader, wireType, message.get(field), options);
+      break;
+    case "map":
+      readMapEntry(reader, message.get(field), options);
+      break;
+  }
+}
+function readMapEntry(reader, map, options) {
+  const field = map.field();
+  let key;
+  let val;
+  const len = reader.uint32();
+  const end = reader.pos + len;
+  while (reader.pos < end) {
+    const [fieldNo] = reader.tag();
+    switch (fieldNo) {
+      case 1:
+        key = readScalar(reader, field.mapKey);
+        break;
+      case 2:
+        switch (field.mapKind) {
+          case "scalar":
+            val = readScalar(reader, field.scalar);
+            break;
+          case "enum":
+            val = reader.int32();
+            break;
+          case "message":
+            val = readMessageField(reader, options, field);
+            break;
+        }
+        break;
+    }
+  }
+  if (key === undefined) {
+    key = scalarZeroValue(field.mapKey, false);
+  }
+  if (val === undefined) {
+    switch (field.mapKind) {
+      case "scalar":
+        val = scalarZeroValue(field.scalar, false);
+        break;
+      case "enum":
+        val = field.enum.values[0].number;
+        break;
+      case "message":
+        val = reflect(field.message, undefined, false);
+        break;
+    }
+  }
+  map.set(key, val);
+}
+function readListField(reader, wireType, list, options) {
+  var _a;
+  const field = list.field();
+  if (field.listKind === "message") {
+    list.add(readMessageField(reader, options, field));
+    return;
+  }
+  const scalarType = (_a = field.scalar) !== null && _a !== undefined ? _a : ScalarType.INT32;
+  const packed = wireType == WireType.LengthDelimited && scalarType != ScalarType.STRING && scalarType != ScalarType.BYTES;
+  if (!packed) {
+    list.add(readScalar(reader, scalarType));
+    return;
+  }
+  const e = reader.uint32() + reader.pos;
+  while (reader.pos < e) {
+    list.add(readScalar(reader, scalarType));
+  }
+}
+function readMessageField(reader, options, field, mergeMessage) {
+  const delimited = field.delimitedEncoding;
+  const message = mergeMessage !== null && mergeMessage !== undefined ? mergeMessage : reflect(field.message, undefined, false);
+  readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+  return message;
+}
+function readScalar(reader, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return reader.string();
+    case ScalarType.BOOL:
+      return reader.bool();
+    case ScalarType.DOUBLE:
+      return reader.double();
+    case ScalarType.FLOAT:
+      return reader.float();
+    case ScalarType.INT32:
+      return reader.int32();
+    case ScalarType.INT64:
+      return reader.int64();
+    case ScalarType.UINT64:
+      return reader.uint64();
+    case ScalarType.FIXED64:
+      return reader.fixed64();
+    case ScalarType.BYTES:
+      return reader.bytes();
+    case ScalarType.FIXED32:
+      return reader.fixed32();
+    case ScalarType.SFIXED32:
+      return reader.sfixed32();
+    case ScalarType.SFIXED64:
+      return reader.sfixed64();
+    case ScalarType.SINT64:
+      return reader.sint64();
+    case ScalarType.UINT32:
+      return reader.uint32();
+    case ScalarType.SINT32:
+      return reader.sint32();
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.js
+function fileDesc(b64, imports) {
+  var _a;
+  const root = fromBinary(FileDescriptorProtoSchema, base64Decode(b64));
+  root.messageType.forEach(restoreJsonNames);
+  root.dependency = (_a = imports === null || imports === undefined ? undefined : imports.map((f) => f.proto.name)) !== null && _a !== undefined ? _a : [];
+  const reg = createFileRegistry(root, (protoFileName) => imports === null || imports === undefined ? undefined : imports.find((f) => f.proto.name === protoFileName));
+  return reg.getFile(root.name);
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.js
+function serviceDesc(file, path, ...paths) {
+  if (paths.length > 0) {
+    throw new Error;
+  }
+  return file.services[path];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/timestamp_pb.js
+var file_google_protobuf_timestamp = /* @__PURE__ */ fileDesc("Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJvdG9idWYiKwoJVGltZXN0YW1wEg8KB3NlY29uZHMYASABKAMSDQoFbmFub3MYAiABKAVChQEKE2NvbS5nb29nbGUucHJvdG9idWZCDlRpbWVzdGFtcFByb3RvUAFaMmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3RpbWVzdGFtcHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM");
+
+// node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/duration_pb.js
+var file_google_protobuf_duration = /* @__PURE__ */ fileDesc("Ch5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiIqCghEdXJhdGlvbhIPCgdzZWNvbmRzGAEgASgDEg0KBW5hbm9zGAIgASgFQoMBChNjb20uZ29vZ2xlLnByb3RvYnVmQg1EdXJhdGlvblByb3RvUAFaMWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2R1cmF0aW9ucGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw");
+
+// src/gen/google/type/latlng_pb.ts
+var file_google_type_latlng = /* @__PURE__ */ fileDesc("Chhnb29nbGUvdHlwZS9sYXRsbmcucHJvdG8SC2dvb2dsZS50eXBlIi0KBkxhdExuZxIQCghsYXRpdHVkZRgBIAEoARIRCglsb25naXR1ZGUYAiABKAFCYAoPY29tLmdvb2dsZS50eXBlQgtMYXRMbmdQcm90b1ABWjhnb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29nbGVhcGlzL3R5cGUvbGF0bG5nO2xhdGxuZ6ICA0dUUGIGcHJvdG8z");
+var LatLngSchema = /* @__PURE__ */ messageDesc(file_google_type_latlng, 0);
+
+// src/gen/caronashow/poc/v1/points_pb.ts
+var file_caronashow_poc_v1_points = /* @__PURE__ */ fileDesc("Ch5jYXJvbmFzaG93L3BvYy92MS9wb2ludHMucHJvdG8SEWNhcm9uYXNob3cucG9jLnYxIkYKB0FkZHJlc3MSJQoIcG9zaXRpb24YASABKAsyEy5nb29nbGUudHlwZS5MYXRMbmcSFAoMZnVsbF9hZGRyZXNzGAIgASgJIj4KB1ZlaGljbGUSFQoNbGljZW5zZV9wbGF0ZRgBIAEoCRINCgVtb2RlbBgCIAEoCRINCgVjb2xvchgDIAEoCSKCAgoGUGVyc29uEgoKAmlkGAEgASgJEgwKBG5hbWUYAiABKAkSDgoGcmF0aW5nGAMgASgBEisKBHJhbmsYBCABKA4yHS5jYXJvbmFzaG93LnBvYy52MS5QZXJzb25SYW5rEisKBGljb24YBSABKA4yHS5jYXJvbmFzaG93LnBvYy52MS5QZXJzb25JY29uEjYKEmRlcGFydHVyZV9mcm9tX29yZxgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPAoZZGVwYXJ0dXJlX3dpbmRvd19mcm9tX29yZxgHIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbiKFAQoOUGFzc2VuZ2VyUG9pbnQSCgoCaWQYASABKAkSKwoHYWRkcmVzcxgCIAEoCzIaLmNhcm9uYXNob3cucG9jLnYxLkFkZHJlc3MSKQoGcGVyc29uGAMgASgLMhkuY2Fyb25hc2hvdy5wb2MudjEuUGVyc29uEg8KB2NvbW1lbnQYBCABKAki3wEKC0RyaXZlclBvaW50EgoKAmlkGAEgASgJEisKB2FkZHJlc3MYAiABKAsyGi5jYXJvbmFzaG93LnBvYy52MS5BZGRyZXNzEikKBnBlcnNvbhgDIAEoCzIZLmNhcm9uYXNob3cucG9jLnYxLlBlcnNvbhIrCgd2ZWhpY2xlGAQgASgLMhouY2Fyb25hc2hvdy5wb2MudjEuVmVoaWNsZRIPCgdjb21tZW50GAUgASgJEhUKDXNlYXRzX29mZmVyZWQYBiABKAUSFwoPc2VhdHNfYXZhaWxhYmxlGAcgASgFIloKEU9yZ2FuaXphdGlvblBvaW50EgoKAmlkGAEgASgJEisKB2FkZHJlc3MYAiABKAsyGi5jYXJvbmFzaG93LnBvYy52MS5BZGRyZXNzEgwKBG5hbWUYAyABKAkqogEKClBlcnNvblJhbmsSGwoXUEVSU09OX1JBTktfVU5TUEVDSUZJRUQQABIWChJQRVJTT05fUkFOS19CUk9OWkUQARIWChJQRVJTT05fUkFOS19TSUxWRVIQAhIUChBQRVJTT05fUkFOS19HT0xEEAMSGAoUUEVSU09OX1JBTktfUExBVElOVU0QBBIXChNQRVJTT05fUkFOS19ESUFNT05EEAUqpwEKClBlcnNvbkljb24SGwoXUEVSU09OX0lDT05fVU5TUEVDSUZJRUQQABIWChJQRVJTT05fSUNPTl9NQUxFXzEQARIWChJQRVJTT05fSUNPTl9NQUxFXzIQAhIYChRQRVJTT05fSUNPTl9GRU1BTEVfMRADEhgKFFBFUlNPTl9JQ09OX0ZFTUFMRV8yEAQSGAoUUEVSU09OX0lDT05fRkVNQUxFXzMQBULEAQoVY29tLmNhcm9uYXNob3cucG9jLnYxQgtQb2ludHNQcm90b1ABWjhnaXRsYWIuY29tL2Nhcm9uYXNob3cvYXBpL2dvL2dlbi9jYXJvbmFzaG93L3BvYy92MTtwb2N2MaICA0NQWKoCEUNhcm9uYXNob3cuUG9jLlYxygIRQ2Fyb25hc2hvd1xQb2NcVjHiAh1DYXJvbmFzaG93XFBvY1xWMVxHUEJNZXRhZGF0YeoCE0Nhcm9uYXNob3c6OlBvYzo6VjFiBnByb3RvMw", [file_google_protobuf_duration, file_google_protobuf_timestamp, file_google_type_latlng]);
+var AddressSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 0);
+var VehicleSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 1);
+var PersonSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 2);
+var PassengerPointSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 3);
+var DriverPointSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 4);
+var OrganizationPointSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_points, 5);
+var PersonRank;
+((PersonRank2) => {
+  PersonRank2[PersonRank2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  PersonRank2[PersonRank2["BRONZE"] = 1] = "BRONZE";
+  PersonRank2[PersonRank2["SILVER"] = 2] = "SILVER";
+  PersonRank2[PersonRank2["GOLD"] = 3] = "GOLD";
+  PersonRank2[PersonRank2["PLATINUM"] = 4] = "PLATINUM";
+  PersonRank2[PersonRank2["DIAMOND"] = 5] = "DIAMOND";
+})(PersonRank ||= {});
+var PersonRankSchema = /* @__PURE__ */ enumDesc(file_caronashow_poc_v1_points, 0);
+var PersonIcon;
+((PersonIcon2) => {
+  PersonIcon2[PersonIcon2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  PersonIcon2[PersonIcon2["MALE_1"] = 1] = "MALE_1";
+  PersonIcon2[PersonIcon2["MALE_2"] = 2] = "MALE_2";
+  PersonIcon2[PersonIcon2["FEMALE_1"] = 3] = "FEMALE_1";
+  PersonIcon2[PersonIcon2["FEMALE_2"] = 4] = "FEMALE_2";
+  PersonIcon2[PersonIcon2["FEMALE_3"] = 5] = "FEMALE_3";
+})(PersonIcon ||= {});
+var PersonIconSchema = /* @__PURE__ */ enumDesc(file_caronashow_poc_v1_points, 1);
+
+// src/gen/caronashow/poc/v1/groups_pb.ts
+var file_caronashow_poc_v1_groups = /* @__PURE__ */ fileDesc("Ch5jYXJvbmFzaG93L3BvYy92MS9ncm91cHMucHJvdG8SEWNhcm9uYXNob3cucG9jLnYxIn8KCk1hdGNoR3JvdXASCgoCaWQYASABKAkSLgoGZHJpdmVyGAIgAygLMh4uY2Fyb25hc2hvdy5wb2MudjEuRHJpdmVyUG9pbnQSNQoKcGFzc2VuZ2VycxgDIAMoCzIhLmNhcm9uYXNob3cucG9jLnYxLlBhc3NlbmdlclBvaW50QsQBChVjb20uY2Fyb25hc2hvdy5wb2MudjFCC0dyb3Vwc1Byb3RvUAFaOGdpdGxhYi5jb20vY2Fyb25hc2hvdy9hcGkvZ28vZ2VuL2Nhcm9uYXNob3cvcG9jL3YxO3BvY3YxogIDQ1BYqgIRQ2Fyb25hc2hvdy5Qb2MuVjHKAhFDYXJvbmFzaG93XFBvY1xWMeICHUNhcm9uYXNob3dcUG9jXFYxXEdQQk1ldGFkYXRh6gITQ2Fyb25hc2hvdzo6UG9jOjpWMWIGcHJvdG8z", [file_caronashow_poc_v1_points]);
+var MatchGroupSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_groups, 0);
+// src/gen/caronashow/poc/v1/routes_pb.ts
+var file_caronashow_poc_v1_routes = /* @__PURE__ */ fileDesc("Ch5jYXJvbmFzaG93L3BvYy92MS9yb3V0ZXMucHJvdG8SEWNhcm9uYXNob3cucG9jLnYxIq8CCgtEaXJlY3RSb3V0ZRIRCgl0YXJnZXRfaWQYASABKAkSNwoLdGFyZ2V0X3R5cGUYAiABKA4yIi5jYXJvbmFzaG93LnBvYy52MS5Sb3V0ZVRhcmdldFR5cGUSFwoPZGlzdGFuY2VfbWV0ZXJzGAMgASgFEisKCGR1cmF0aW9uGAQgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEjYKEmRlcGFydHVyZV9mcm9tX29yZxgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPAoZZGVwYXJ0dXJlX3dpbmRvd19mcm9tX29yZxgGIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbhIYChBlbmNvZGVkX3BvbHlsaW5lGAcgASgJIoQCCg5PcHRpbWl6ZWRSb3V0ZRIcChR0YXJnZXRfcGFzc2VuZ2VyX2lkcxgBIAMoCRIXCg9kaXN0YW5jZV9tZXRlcnMYAyABKAUSKwoIZHVyYXRpb24YBCABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb24SNgoSZGVwYXJ0dXJlX2Zyb21fb3JnGAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI8ChlkZXBhcnR1cmVfd2luZG93X2Zyb21fb3JnGAYgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEhgKEGVuY29kZWRfcG9seWxpbmUYByABKAkqcwoPUm91dGVUYXJnZXRUeXBlEiEKHVJPVVRFX1RBUkdFVF9UWVBFX1VOU1BFQ0lGSUVEEAASHwobUk9VVEVfVEFSR0VUX1RZUEVfUEFTU0VOR0VSEAESHAoYUk9VVEVfVEFSR0VUX1RZUEVfRFJJVkVSEAJCxAEKFWNvbS5jYXJvbmFzaG93LnBvYy52MUILUm91dGVzUHJvdG9QAVo4Z2l0bGFiLmNvbS9jYXJvbmFzaG93L2FwaS9nby9nZW4vY2Fyb25hc2hvdy9wb2MvdjE7cG9jdjGiAgNDUFiqAhFDYXJvbmFzaG93LlBvYy5WMcoCEUNhcm9uYXNob3dcUG9jXFYx4gIdQ2Fyb25hc2hvd1xQb2NcVjFcR1BCTWV0YWRhdGHqAhNDYXJvbmFzaG93OjpQb2M6OlYxYgZwcm90bzM", [file_google_protobuf_duration, file_google_protobuf_timestamp]);
+var DirectRouteSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_routes, 0);
+var OptimizedRouteSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_routes, 1);
+var RouteTargetType;
+((RouteTargetType2) => {
+  RouteTargetType2[RouteTargetType2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  RouteTargetType2[RouteTargetType2["PASSENGER"] = 1] = "PASSENGER";
+  RouteTargetType2[RouteTargetType2["DRIVER"] = 2] = "DRIVER";
+})(RouteTargetType ||= {});
+var RouteTargetTypeSchema = /* @__PURE__ */ enumDesc(file_caronashow_poc_v1_routes, 0);
+
+// src/gen/caronashow/poc/v1/poc_pb.ts
+var file_caronashow_poc_v1_poc = /* @__PURE__ */ fileDesc("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", [file_caronashow_poc_v1_groups, file_caronashow_poc_v1_points, file_caronashow_poc_v1_routes]);
+var GetMapPointsRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 0);
+var GetMapPointsResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 1);
+var GetDirectRoutesRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 2);
+var GetDirectRoutesResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 3);
+var GetMapPointGroupsRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 4);
+var GetMapPointGroupsResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 5);
+var GetOptimizedRoutesRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 6);
+var GetOptimizedRoutesResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_poc_v1_poc, 7);
+var Dataset;
+((Dataset2) => {
+  Dataset2[Dataset2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  Dataset2[Dataset2["ATLANTA_10"] = 1] = "ATLANTA_10";
+  Dataset2[Dataset2["ATLANTA_25"] = 2] = "ATLANTA_25";
+  Dataset2[Dataset2["ATLANTA_50"] = 3] = "ATLANTA_50";
+})(Dataset ||= {});
+var DatasetSchema = /* @__PURE__ */ enumDesc(file_caronashow_poc_v1_poc, 0);
+var PocService = /* @__PURE__ */ serviceDesc(file_caronashow_poc_v1_poc, 0);
+// src/gen/caronashow/pooler/v1/pooler_pb.ts
+var file_caronashow_pooler_v1_pooler = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_duration, file_google_protobuf_timestamp]);
+var OperationSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 0);
+var ExecuteMatchingAlgorithmOnDatasetRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 1);
+var ExecuteMatchingAlgorithmOnDatasetResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 2);
+var ListOperationsRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 3);
+var ListOperationsResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 4);
+var GetStateOfOperationRequestSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 5);
+var GetStateOfOperationResponseSchema = /* @__PURE__ */ messageDesc(file_caronashow_pooler_v1_pooler, 6);
+var MatchingAlgorithm;
+((MatchingAlgorithm2) => {
+  MatchingAlgorithm2[MatchingAlgorithm2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  MatchingAlgorithm2[MatchingAlgorithm2["RANDOM"] = 1] = "RANDOM";
+  MatchingAlgorithm2[MatchingAlgorithm2["ROUTE_SIMILARITY"] = 2] = "ROUTE_SIMILARITY";
+  MatchingAlgorithm2[MatchingAlgorithm2["POINT_DISTANCE"] = 3] = "POINT_DISTANCE";
+  MatchingAlgorithm2[MatchingAlgorithm2["FULL"] = 4] = "FULL";
+})(MatchingAlgorithm ||= {});
+var MatchingAlgorithmSchema = /* @__PURE__ */ enumDesc(file_caronashow_pooler_v1_pooler, 0);
+var OperationState;
+((OperationState2) => {
+  OperationState2[OperationState2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  OperationState2[OperationState2["PENDING"] = 1] = "PENDING";
+  OperationState2[OperationState2["RUNNING"] = 2] = "RUNNING";
+  OperationState2[OperationState2["SUCCEEDED"] = 3] = "SUCCEEDED";
+  OperationState2[OperationState2["FAILED"] = 4] = "FAILED";
+})(OperationState ||= {});
+var OperationStateSchema = /* @__PURE__ */ enumDesc(file_caronashow_pooler_v1_pooler, 1);
+var PoolerService = /* @__PURE__ */ serviceDesc(file_caronashow_pooler_v1_pooler, 0);
+// src/gen/caronashow/service/v1/map_pb.ts
+var file_caronashow_service_v1_map = /* @__PURE__ */ fileDesc("Ch9jYXJvbmFzaG93L3NlcnZpY2UvdjEvbWFwLnByb3RvEhVjYXJvbmFzaG93LnNlcnZpY2UudjEyDAoKTWFwU2VydmljZULdAQoZY29tLmNhcm9uYXNob3cuc2VydmljZS52MUIITWFwUHJvdG9QAVpAZ2l0bGFiLmNvbS9jYXJvbmFzaG93L2FwaS9nby9nZW4vY2Fyb25hc2hvdy9zZXJ2aWNlL3YxO3NlcnZpY2V2MaICA0NTWKoCFUNhcm9uYXNob3cuU2VydmljZS5WMcoCFUNhcm9uYXNob3dcU2VydmljZVxWMeICIUNhcm9uYXNob3dcU2VydmljZVxWMVxHUEJNZXRhZGF0YeoCF0Nhcm9uYXNob3c6OlNlcnZpY2U6OlYxYgZwcm90bzM");
+var MapService = /* @__PURE__ */ serviceDesc(file_caronashow_service_v1_map, 0);
+// src/gen/caronashow/types/v1/user_pb.ts
+var file_caronashow_types_v1_user = /* @__PURE__ */ fileDesc("Ch5jYXJvbmFzaG93L3R5cGVzL3YxL3VzZXIucHJvdG8SE2Nhcm9uYXNob3cudHlwZXMudjEiWgoEVXNlchIKCgJpZBgBIAEoCRIQCgh1c2VybmFtZRgCIAEoCRISCgpmaXJzdF9uYW1lGAMgASgJEhEKCWxhc3RfbmFtZRgEIAEoCRINCgVlbWFpbBgFIAEoCULQAQoXY29tLmNhcm9uYXNob3cudHlwZXMudjFCCVVzZXJQcm90b1ABWjxnaXRsYWIuY29tL2Nhcm9uYXNob3cvYXBpL2dvL2dlbi9jYXJvbmFzaG93L3R5cGVzL3YxO3R5cGVzdjGiAgNDVFiqAhNDYXJvbmFzaG93LlR5cGVzLlYxygITQ2Fyb25hc2hvd1xUeXBlc1xWMeICH0Nhcm9uYXNob3dcVHlwZXNcVjFcR1BCTWV0YWRhdGHqAhVDYXJvbmFzaG93OjpUeXBlczo6VjFiBnByb3RvMw");
+var UserSchema = /* @__PURE__ */ messageDesc(file_caronashow_types_v1_user, 0);