@code0-tech/definition-reader 0.0.14 → 0.0.16

package/dist/definition-reader.js

@@ -0,0 +1,3911 @@
+import { readdirSync as Ve, readFileSync as Ae } from "node:fs";
+import je from "node:path";
+function De(a) {
+  let e = typeof a;
+  if (e == "object") {
+    if (Array.isArray(a))
+      return "array";
+    if (a === null)
+      return "null";
+  }
+  return e;
+}
+function Pe(a) {
+  return a !== null && typeof a == "object" && !Array.isArray(a);
+}
+let K = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""), q = [];
+for (let a = 0; a < K.length; a++)
+  q[K[a].charCodeAt(0)] = a;
+q[45] = K.indexOf("+");
+q[95] = K.indexOf("/");
+function _e(a) {
+  let e = a.length * 3 / 4;
+  a[a.length - 2] == "=" ? e -= 2 : a[a.length - 1] == "=" && (e -= 1);
+  let t = new Uint8Array(e), n = 0, r = 0, i, l = 0;
+  for (let s = 0; s < a.length; s++) {
+    if (i = q[a.charCodeAt(s)], i === void 0)
+      switch (a[s]) {
+        case "=":
+          r = 0;
+        // reset state when padding found
+        case `
+`:
+        case "\r":
+        case "	":
+        case " ":
+          continue;
+        // skip white-space, and padding
+        default:
+          throw Error("invalid base64 string.");
+      }
+    switch (r) {
+      case 0:
+        l = i, r = 1;
+        break;
+      case 1:
+        t[n++] = l << 2 | (i & 48) >> 4, l = i, r = 2;
+        break;
+      case 2:
+        t[n++] = (l & 15) << 4 | (i & 60) >> 2, l = i, r = 3;
+        break;
+      case 3:
+        t[n++] = (l & 3) << 6 | i, r = 0;
+        break;
+    }
+  }
+  if (r == 1)
+    throw Error("invalid base64 string.");
+  return t.subarray(0, n);
+}
+function Se(a) {
+  let e = "", t = 0, n, r = 0;
+  for (let i = 0; i < a.length; i++)
+    switch (n = a[i], t) {
+      case 0:
+        e += K[n >> 2], r = (n & 3) << 4, t = 1;
+        break;
+      case 1:
+        e += K[r | n >> 4], r = (n & 15) << 2, t = 2;
+        break;
+      case 2:
+        e += K[r | n >> 6], e += K[n & 63], t = 0;
+        break;
+    }
+  return t && (e += K[r], e += "=", t == 1 && (e += "=")), e;
+}
+var d;
+(function(a) {
+  a.symbol = Symbol.for("protobuf-ts/unknown"), a.onRead = (t, n, r, i, l) => {
+    (e(n) ? n[a.symbol] : n[a.symbol] = []).push({ no: r, wireType: i, data: l });
+  }, a.onWrite = (t, n, r) => {
+    for (let { no: i, wireType: l, data: s } of a.list(n))
+      r.tag(i, l).raw(s);
+  }, a.list = (t, n) => {
+    if (e(t)) {
+      let r = t[a.symbol];
+      return n ? r.filter((i) => i.no == n) : r;
+    }
+    return [];
+  }, a.last = (t, n) => a.list(t, n).slice(-1)[0];
+  const e = (t) => t && Array.isArray(t[a.symbol]);
+})(d || (d = {}));
+var u;
+(function(a) {
+  a[a.Varint = 0] = "Varint", a[a.Bit64 = 1] = "Bit64", a[a.LengthDelimited = 2] = "LengthDelimited", a[a.StartGroup = 3] = "StartGroup", a[a.EndGroup = 4] = "EndGroup", a[a.Bit32 = 5] = "Bit32";
+})(u || (u = {}));
+function Me() {
+  let a = 0, e = 0;
+  for (let n = 0; n < 28; n += 7) {
+    let r = this.buf[this.pos++];
+    if (a |= (r & 127) << n, (r & 128) == 0)
+      return this.assertBounds(), [a, e];
+  }
+  let t = this.buf[this.pos++];
+  if (a |= (t & 15) << 28, e = (t & 112) >> 4, (t & 128) == 0)
+    return this.assertBounds(), [a, e];
+  for (let n = 3; n <= 31; n += 7) {
+    let r = this.buf[this.pos++];
+    if (e |= (r & 127) << n, (r & 128) == 0)
+      return this.assertBounds(), [a, e];
+  }
+  throw new Error("invalid varint");
+}
+function Q(a, e, t) {
+  for (let i = 0; i < 28; i = i + 7) {
+    const l = a >>> i, s = !(!(l >>> 7) && e == 0), o = (s ? l | 128 : l) & 255;
+    if (t.push(o), !s)
+      return;
+  }
+  const n = a >>> 28 & 15 | (e & 7) << 4, r = e >> 3 != 0;
+  if (t.push((r ? n | 128 : n) & 255), !!r) {
+    for (let i = 3; i < 31; i = i + 7) {
+      const l = e >>> i, s = !!(l >>> 7), o = (s ? l | 128 : l) & 255;
+      if (t.push(o), !s)
+        return;
+    }
+    t.push(e >>> 31 & 1);
+  }
+}
+const G = 65536 * 65536;
+function Oe(a) {
+  let e = a[0] == "-";
+  e && (a = a.slice(1));
+  const t = 1e6;
+  let n = 0, r = 0;
+  function i(l, s) {
+    const o = Number(a.slice(l, s));
+    r *= t, n = n * t + o, n >= G && (r = r + (n / G | 0), n = n % G);
+  }
+  return i(-24, -18), i(-18, -12), i(-12, -6), i(-6), [e, n, r];
+}
+function ge(a, e) {
+  if (e >>> 0 <= 2097151)
+    return "" + (G * e + (a >>> 0));
+  let t = a & 16777215, n = (a >>> 24 | e << 8) >>> 0 & 16777215, r = e >> 16 & 65535, i = t + n * 6777216 + r * 6710656, l = n + r * 8147497, s = r * 2, o = 1e7;
+  i >= o && (l += Math.floor(i / o), i %= o), l >= o && (s += Math.floor(l / o), l %= o);
+  function f(h, g) {
+    let k = h ? String(h) : "";
+    return g ? "0000000".slice(k.length) + k : k;
+  }
+  return f(
+    s,
+    /*needLeadingZeros=*/
+    0
+  ) + f(
+    l,
+    /*needLeadingZeros=*/
+    s
+  ) + // If the final 1e7 digit didn't need leading zeros, we would have
+  // returned via the trivial code path at the top.
+  f(
+    i,
+    /*needLeadingZeros=*/
+    1
+  );
+}
+function Te(a, e) {
+  if (a >= 0) {
+    for (; a > 127; )
+      e.push(a & 127 | 128), a = a >>> 7;
+    e.push(a);
+  } else {
+    for (let t = 0; t < 9; t++)
+      e.push(a & 127 | 128), a = a >> 7;
+    e.push(1);
+  }
+}
+function Xe() {
+  let a = this.buf[this.pos++], e = a & 127;
+  if ((a & 128) == 0)
+    return this.assertBounds(), e;
+  if (a = this.buf[this.pos++], e |= (a & 127) << 7, (a & 128) == 0)
+    return this.assertBounds(), e;
+  if (a = this.buf[this.pos++], e |= (a & 127) << 14, (a & 128) == 0)
+    return this.assertBounds(), e;
+  if (a = this.buf[this.pos++], e |= (a & 127) << 21, (a & 128) == 0)
+    return this.assertBounds(), e;
+  a = this.buf[this.pos++], e |= (a & 15) << 28;
+  for (let t = 5; (a & 128) !== 0 && t < 10; t++)
+    a = this.buf[this.pos++];
+  if ((a & 128) != 0)
+    throw new Error("invalid varint");
+  return this.assertBounds(), e >>> 0;
+}
+let T;
+function Ge() {
+  const a = new DataView(new ArrayBuffer(8));
+  T = globalThis.BigInt !== void 0 && typeof a.getBigInt64 == "function" && typeof a.getBigUint64 == "function" && typeof a.setBigInt64 == "function" && typeof a.setBigUint64 == "function" ? {
+    MIN: BigInt("-9223372036854775808"),
+    MAX: BigInt("9223372036854775807"),
+    UMIN: BigInt("0"),
+    UMAX: BigInt("18446744073709551615"),
+    C: BigInt,
+    V: a
+  } : void 0;
+}
+Ge();
+function Fe(a) {
+  if (!a)
+    throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support");
+}
+const Ue = /^-?[0-9]+$/, J = 4294967296, M = 2147483648;
+class $e {
+  /**
+   * Create a new instance with the given bits.
+   */
+  constructor(e, t) {
+    this.lo = e | 0, this.hi = t | 0;
+  }
+  /**
+   * Is this instance equal to 0?
+   */
+  isZero() {
+    return this.lo == 0 && this.hi == 0;
+  }
+  /**
+   * Convert to a native number.
+   */
+  toNumber() {
+    let e = this.hi * J + (this.lo >>> 0);
+    if (!Number.isSafeInteger(e))
+      throw new Error("cannot convert to safe number");
+    return e;
+  }
+}
+class B extends $e {
+  /**
+   * Create instance from a `string`, `number` or `bigint`.
+   */
+  static from(e) {
+    if (T)
+      switch (typeof e) {
+        case "string":
+          if (e == "0")
+            return this.ZERO;
+          if (e == "")
+            throw new Error("string is no integer");
+          e = T.C(e);
+        case "number":
+          if (e === 0)
+            return this.ZERO;
+          e = T.C(e);
+        case "bigint":
+          if (!e)
+            return this.ZERO;
+          if (e < T.UMIN)
+            throw new Error("signed value for ulong");
+          if (e > T.UMAX)
+            throw new Error("ulong too large");
+          return T.V.setBigUint64(0, e, !0), new B(T.V.getInt32(0, !0), T.V.getInt32(4, !0));
+      }
+    else
+      switch (typeof e) {
+        case "string":
+          if (e == "0")
+            return this.ZERO;
+          if (e = e.trim(), !Ue.test(e))
+            throw new Error("string is no integer");
+          let [t, n, r] = Oe(e);
+          if (t)
+            throw new Error("signed value for ulong");
+          return new B(n, r);
+        case "number":
+          if (e == 0)
+            return this.ZERO;
+          if (!Number.isSafeInteger(e))
+            throw new Error("number is no integer");
+          if (e < 0)
+            throw new Error("signed value for ulong");
+          return new B(e, e / J);
+      }
+    throw new Error("unknown value " + typeof e);
+  }
+  /**
+   * Convert to decimal string.
+   */
+  toString() {
+    return T ? this.toBigInt().toString() : ge(this.lo, this.hi);
+  }
+  /**
+   * Convert to native bigint.
+   */
+  toBigInt() {
+    return Fe(T), T.V.setInt32(0, this.lo, !0), T.V.setInt32(4, this.hi, !0), T.V.getBigUint64(0, !0);
+  }
+}
+B.ZERO = new B(0, 0);
+class N extends $e {
+  /**
+   * Create instance from a `string`, `number` or `bigint`.
+   */
+  static from(e) {
+    if (T)
+      switch (typeof e) {
+        case "string":
+          if (e == "0")
+            return this.ZERO;
+          if (e == "")
+            throw new Error("string is no integer");
+          e = T.C(e);
+        case "number":
+          if (e === 0)
+            return this.ZERO;
+          e = T.C(e);
+        case "bigint":
+          if (!e)
+            return this.ZERO;
+          if (e < T.MIN)
+            throw new Error("signed long too small");
+          if (e > T.MAX)
+            throw new Error("signed long too large");
+          return T.V.setBigInt64(0, e, !0), new N(T.V.getInt32(0, !0), T.V.getInt32(4, !0));
+      }
+    else
+      switch (typeof e) {
+        case "string":
+          if (e == "0")
+            return this.ZERO;
+          if (e = e.trim(), !Ue.test(e))
+            throw new Error("string is no integer");
+          let [t, n, r] = Oe(e);
+          if (t) {
+            if (r > M || r == M && n != 0)
+              throw new Error("signed long too small");
+          } else if (r >= M)
+            throw new Error("signed long too large");
+          let i = new N(n, r);
+          return t ? i.negate() : i;
+        case "number":
+          if (e == 0)
+            return this.ZERO;
+          if (!Number.isSafeInteger(e))
+            throw new Error("number is no integer");
+          return e > 0 ? new N(e, e / J) : new N(-e, -e / J).negate();
+      }
+    throw new Error("unknown value " + typeof e);
+  }
+  /**
+   * Do we have a minus sign?
+   */
+  isNegative() {
+    return (this.hi & M) !== 0;
+  }
+  /**
+   * Negate two's complement.
+   * Invert all the bits and add one to the result.
+   */
+  negate() {
+    let e = ~this.hi, t = this.lo;
+    return t ? t = ~t + 1 : e += 1, new N(t, e);
+  }
+  /**
+   * Convert to decimal string.
+   */
+  toString() {
+    if (T)
+      return this.toBigInt().toString();
+    if (this.isNegative()) {
+      let e = this.negate();
+      return "-" + ge(e.lo, e.hi);
+    }
+    return ge(this.lo, this.hi);
+  }
+  /**
+   * Convert to native bigint.
+   */
+  toBigInt() {
+    return Fe(T), T.V.setInt32(0, this.lo, !0), T.V.setInt32(4, this.hi, !0), T.V.getBigInt64(0, !0);
+  }
+}
+N.ZERO = new N(0, 0);
+const be = {
+  readUnknownField: !0,
+  readerFactory: (a) => new Ye(a)
+};
+function Je(a) {
+  return a ? Object.assign(Object.assign({}, be), a) : be;
+}
+class Ye {
+  constructor(e, t) {
+    this.varint64 = Me, this.uint32 = Xe, this.buf = e, this.len = e.length, this.pos = 0, this.view = new DataView(e.buffer, e.byteOffset, e.byteLength), this.textDecoder = t ?? new TextDecoder("utf-8", {
+      fatal: !0,
+      ignoreBOM: !0
+    });
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let e = this.uint32(), t = e >>> 3, n = e & 7;
+    if (t <= 0 || n < 0 || n > 5)
+      throw new Error("illegal tag: field no " + t + " wire type " + n);
+    return [t, n];
+  }
+  /**
+   * Skip one element on the wire and return the skipped data.
+   * Supports WireType.StartGroup since v2.0.0-alpha.23.
+   */
+  skip(e) {
+    let t = this.pos;
+    switch (e) {
+      case u.Varint:
+        for (; this.buf[this.pos++] & 128; )
+          ;
+        break;
+      case u.Bit64:
+        this.pos += 4;
+      case u.Bit32:
+        this.pos += 4;
+        break;
+      case u.LengthDelimited:
+        let n = this.uint32();
+        this.pos += n;
+        break;
+      case u.StartGroup:
+        let r;
+        for (; (r = this.tag()[1]) !== u.EndGroup; )
+          this.skip(r);
+        break;
+      default:
+        throw new Error("cant skip wire type " + e);
+    }
+    return this.assertBounds(), this.buf.subarray(t, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let e = this.uint32();
+    return e >>> 1 ^ -(e & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return new N(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return new B(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [e, t] = this.varint64(), n = -(e & 1);
+    return e = (e >>> 1 | (t & 1) << 31) ^ n, t = t >>> 1 ^ n, new N(e, t);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [e, t] = this.varint64();
+    return e !== 0 || t !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return new B(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return new N(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, !0);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let e = this.uint32(), t = this.pos;
+    return this.pos += e, this.assertBounds(), this.buf.subarray(t, t + e);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.textDecoder.decode(this.bytes());
+  }
+}
+function y(a, e) {
+  if (!a)
+    throw new Error(e);
+}
+const Ze = 34028234663852886e22, ve = -34028234663852886e22, qe = 4294967295, ze = 2147483647, Qe = -2147483648;
+function _(a) {
+  if (typeof a != "number")
+    throw new Error("invalid int 32: " + typeof a);
+  if (!Number.isInteger(a) || a > ze || a < Qe)
+    throw new Error("invalid int 32: " + a);
+}
+function Y(a) {
+  if (typeof a != "number")
+    throw new Error("invalid uint 32: " + typeof a);
+  if (!Number.isInteger(a) || a > qe || a < 0)
+    throw new Error("invalid uint 32: " + a);
+}
+function ke(a) {
+  if (typeof a != "number")
+    throw new Error("invalid float 32: " + typeof a);
+  if (Number.isFinite(a) && (a > Ze || a < ve))
+    throw new Error("invalid float 32: " + a);
+}
+const we = {
+  writeUnknownFields: !0,
+  writerFactory: () => new et()
+};
+function He(a) {
+  return a ? Object.assign(Object.assign({}, we), a) : we;
+}
+class et {
+  constructor(e) {
+    this.stack = [], this.textEncoder = e ?? new TextEncoder(), this.chunks = [], this.buf = [];
+  }
+  /**
+   * Return all bytes written and reset this writer.
+   */
+  finish() {
+    this.chunks.push(new Uint8Array(this.buf));
+    let e = 0;
+    for (let r = 0; r < this.chunks.length; r++)
+      e += this.chunks[r].length;
+    let t = new Uint8Array(e), n = 0;
+    for (let r = 0; r < this.chunks.length; r++)
+      t.set(this.chunks[r], n), n += this.chunks[r].length;
+    return this.chunks = [], t;
+  }
+  /**
+   * Start a new fork for length-delimited data like a message
+   * or a packed repeated field.
+   *
+   * Must be joined later with `join()`.
+   */
+  fork() {
+    return this.stack.push({ chunks: this.chunks, buf: this.buf }), this.chunks = [], this.buf = [], this;
+  }
+  /**
+   * Join the last fork. Write its length and bytes, then
+   * return to the previous state.
+   */
+  join() {
+    let e = this.finish(), t = this.stack.pop();
+    if (!t)
+      throw new Error("invalid state, fork stack empty");
+    return this.chunks = t.chunks, this.buf = t.buf, this.uint32(e.byteLength), this.raw(e);
+  }
+  /**
+   * Writes a tag (field number and wire type).
+   *
+   * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+   *
+   * Generated code should compute the tag ahead of time and call `uint32()`.
+   */
+  tag(e, t) {
+    return this.uint32((e << 3 | t) >>> 0);
+  }
+  /**
+   * Write a chunk of raw bytes.
+   */
+  raw(e) {
+    return this.buf.length && (this.chunks.push(new Uint8Array(this.buf)), this.buf = []), this.chunks.push(e), this;
+  }
+  /**
+   * Write a `uint32` value, an unsigned 32 bit varint.
+   */
+  uint32(e) {
+    for (Y(e); e > 127; )
+      this.buf.push(e & 127 | 128), e = e >>> 7;
+    return this.buf.push(e), this;
+  }
+  /**
+   * Write a `int32` value, a signed 32 bit varint.
+   */
+  int32(e) {
+    return _(e), Te(e, this.buf), this;
+  }
+  /**
+   * Write a `bool` value, a variant.
+   */
+  bool(e) {
+    return this.buf.push(e ? 1 : 0), this;
+  }
+  /**
+   * Write a `bytes` value, length-delimited arbitrary data.
+   */
+  bytes(e) {
+    return this.uint32(e.byteLength), this.raw(e);
+  }
+  /**
+   * Write a `string` value, length-delimited data converted to UTF-8 text.
+   */
+  string(e) {
+    let t = this.textEncoder.encode(e);
+    return this.uint32(t.byteLength), this.raw(t);
+  }
+  /**
+   * Write a `float` value, 32-bit floating point number.
+   */
+  float(e) {
+    ke(e);
+    let t = new Uint8Array(4);
+    return new DataView(t.buffer).setFloat32(0, e, !0), this.raw(t);
+  }
+  /**
+   * Write a `double` value, a 64-bit floating point number.
+   */
+  double(e) {
+    let t = new Uint8Array(8);
+    return new DataView(t.buffer).setFloat64(0, e, !0), this.raw(t);
+  }
+  /**
+   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(e) {
+    Y(e);
+    let t = new Uint8Array(4);
+    return new DataView(t.buffer).setUint32(0, e, !0), this.raw(t);
+  }
+  /**
+   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(e) {
+    _(e);
+    let t = new Uint8Array(4);
+    return new DataView(t.buffer).setInt32(0, e, !0), this.raw(t);
+  }
+  /**
+   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(e) {
+    return _(e), e = (e << 1 ^ e >> 31) >>> 0, Te(e, this.buf), this;
+  }
+  /**
+   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(e) {
+    let t = new Uint8Array(8), n = new DataView(t.buffer), r = N.from(e);
+    return n.setInt32(0, r.lo, !0), n.setInt32(4, r.hi, !0), this.raw(t);
+  }
+  /**
+   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(e) {
+    let t = new Uint8Array(8), n = new DataView(t.buffer), r = B.from(e);
+    return n.setInt32(0, r.lo, !0), n.setInt32(4, r.hi, !0), this.raw(t);
+  }
+  /**
+   * Write a `int64` value, a signed 64-bit varint.
+   */
+  int64(e) {
+    let t = N.from(e);
+    return Q(t.lo, t.hi, this.buf), this;
+  }
+  /**
+   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(e) {
+    let t = N.from(e), n = t.hi >> 31, r = t.lo << 1 ^ n, i = (t.hi << 1 | t.lo >>> 31) ^ n;
+    return Q(r, i, this.buf), this;
+  }
+  /**
+   * Write a `uint64` value, an unsigned 64-bit varint.
+   */
+  uint64(e) {
+    let t = B.from(e);
+    return Q(t.lo, t.hi, this.buf), this;
+  }
+}
+const Ne = {
+  emitDefaultValues: !1,
+  enumAsInteger: !1,
+  useProtoFieldName: !1,
+  prettySpaces: 0
+}, Ie = {
+  ignoreUnknownFields: !1
+};
+function tt(a) {
+  return a ? Object.assign(Object.assign({}, Ie), a) : Ie;
+}
+function nt(a) {
+  return a ? Object.assign(Object.assign({}, Ne), a) : Ne;
+}
+const Le = Symbol.for("protobuf-ts/message-type");
+function Be(a) {
+  let e = !1;
+  const t = [];
+  for (let n = 0; n < a.length; n++) {
+    let r = a.charAt(n);
+    r == "_" ? e = !0 : /\d/.test(r) ? (t.push(r), e = !0) : e ? (t.push(r.toUpperCase()), e = !1) : n == 0 ? t.push(r.toLowerCase()) : t.push(r);
+  }
+  return t.join("");
+}
+var c;
+(function(a) {
+  a[a.DOUBLE = 1] = "DOUBLE", a[a.FLOAT = 2] = "FLOAT", a[a.INT64 = 3] = "INT64", a[a.UINT64 = 4] = "UINT64", a[a.INT32 = 5] = "INT32", a[a.FIXED64 = 6] = "FIXED64", a[a.FIXED32 = 7] = "FIXED32", a[a.BOOL = 8] = "BOOL", a[a.STRING = 9] = "STRING", a[a.BYTES = 12] = "BYTES", a[a.UINT32 = 13] = "UINT32", a[a.SFIXED32 = 15] = "SFIXED32", a[a.SFIXED64 = 16] = "SFIXED64", a[a.SINT32 = 17] = "SINT32", a[a.SINT64 = 18] = "SINT64";
+})(c || (c = {}));
+var F;
+(function(a) {
+  a[a.BIGINT = 0] = "BIGINT", a[a.STRING = 1] = "STRING", a[a.NUMBER = 2] = "NUMBER";
+})(F || (F = {}));
+var Z;
+(function(a) {
+  a[a.NO = 0] = "NO", a[a.PACKED = 1] = "PACKED", a[a.UNPACKED = 2] = "UNPACKED";
+})(Z || (Z = {}));
+function it(a) {
+  var e, t, n, r;
+  return a.localName = (e = a.localName) !== null && e !== void 0 ? e : Be(a.name), a.jsonName = (t = a.jsonName) !== null && t !== void 0 ? t : Be(a.name), a.repeat = (n = a.repeat) !== null && n !== void 0 ? n : Z.NO, a.opt = (r = a.opt) !== null && r !== void 0 ? r : a.repeat || a.oneof ? !1 : a.kind == "message", a;
+}
+function rt(a) {
+  if (typeof a != "object" || a === null || !a.hasOwnProperty("oneofKind"))
+    return !1;
+  switch (typeof a.oneofKind) {
+    case "string":
+      return a[a.oneofKind] === void 0 ? !1 : Object.keys(a).length == 2;
+    case "undefined":
+      return Object.keys(a).length == 1;
+    default:
+      return !1;
+  }
+}
+class at {
+  constructor(e) {
+    var t;
+    this.fields = (t = e.fields) !== null && t !== void 0 ? t : [];
+  }
+  prepare() {
+    if (this.data)
+      return;
+    const e = [], t = [], n = [];
+    for (let r of this.fields)
+      if (r.oneof)
+        n.includes(r.oneof) || (n.push(r.oneof), e.push(r.oneof), t.push(r.oneof));
+      else
+        switch (t.push(r.localName), r.kind) {
+          case "scalar":
+          case "enum":
+            (!r.opt || r.repeat) && e.push(r.localName);
+            break;
+          case "message":
+            r.repeat && e.push(r.localName);
+            break;
+          case "map":
+            e.push(r.localName);
+            break;
+        }
+    this.data = { req: e, known: t, oneofs: Object.values(n) };
+  }
+  /**
+   * Is the argument a valid message as specified by the
+   * reflection information?
+   *
+   * Checks all field types recursively. The `depth`
+   * specifies how deep into the structure the check will be.
+   *
+   * With a depth of 0, only the presence of fields
+   * is checked.
+   *
+   * With a depth of 1 or more, the field types are checked.
+   *
+   * With a depth of 2 or more, the members of map, repeated
+   * and message fields are checked.
+   *
+   * Message fields will be checked recursively with depth - 1.
+   *
+   * The number of map entries / repeated values being checked
+   * is < depth.
+   */
+  is(e, t, n = !1) {
+    if (t < 0)
+      return !0;
+    if (e == null || typeof e != "object")
+      return !1;
+    this.prepare();
+    let r = Object.keys(e), i = this.data;
+    if (r.length < i.req.length || i.req.some((l) => !r.includes(l)) || !n && r.some((l) => !i.known.includes(l)))
+      return !1;
+    if (t < 1)
+      return !0;
+    for (const l of i.oneofs) {
+      const s = e[l];
+      if (!rt(s))
+        return !1;
+      if (s.oneofKind === void 0)
+        continue;
+      const o = this.fields.find((f) => f.localName === s.oneofKind);
+      if (!o || !this.field(s[s.oneofKind], o, n, t))
+        return !1;
+    }
+    for (const l of this.fields)
+      if (l.oneof === void 0 && !this.field(e[l.localName], l, n, t))
+        return !1;
+    return !0;
+  }
+  field(e, t, n, r) {
+    let i = t.repeat;
+    switch (t.kind) {
+      case "scalar":
+        return e === void 0 ? t.opt : i ? this.scalars(e, t.T, r, t.L) : this.scalar(e, t.T, t.L);
+      case "enum":
+        return e === void 0 ? t.opt : i ? this.scalars(e, c.INT32, r) : this.scalar(e, c.INT32);
+      case "message":
+        return e === void 0 ? !0 : i ? this.messages(e, t.T(), n, r) : this.message(e, t.T(), n, r);
+      case "map":
+        if (typeof e != "object" || e === null)
+          return !1;
+        if (r < 2)
+          return !0;
+        if (!this.mapKeys(e, t.K, r))
+          return !1;
+        switch (t.V.kind) {
+          case "scalar":
+            return this.scalars(Object.values(e), t.V.T, r, t.V.L);
+          case "enum":
+            return this.scalars(Object.values(e), c.INT32, r);
+          case "message":
+            return this.messages(Object.values(e), t.V.T(), n, r);
+        }
+        break;
+    }
+    return !0;
+  }
+  message(e, t, n, r) {
+    return n ? t.isAssignable(e, r) : t.is(e, r);
+  }
+  messages(e, t, n, r) {
+    if (!Array.isArray(e))
+      return !1;
+    if (r < 2)
+      return !0;
+    if (n) {
+      for (let i = 0; i < e.length && i < r; i++)
+        if (!t.isAssignable(e[i], r - 1))
+          return !1;
+    } else
+      for (let i = 0; i < e.length && i < r; i++)
+        if (!t.is(e[i], r - 1))
+          return !1;
+    return !0;
+  }
+  scalar(e, t, n) {
+    let r = typeof e;
+    switch (t) {
+      case c.UINT64:
+      case c.FIXED64:
+      case c.INT64:
+      case c.SFIXED64:
+      case c.SINT64:
+        switch (n) {
+          case F.BIGINT:
+            return r == "bigint";
+          case F.NUMBER:
+            return r == "number" && !isNaN(e);
+          default:
+            return r == "string";
+        }
+      case c.BOOL:
+        return r == "boolean";
+      case c.STRING:
+        return r == "string";
+      case c.BYTES:
+        return e instanceof Uint8Array;
+      case c.DOUBLE:
+      case c.FLOAT:
+        return r == "number" && !isNaN(e);
+      default:
+        return r == "number" && Number.isInteger(e);
+    }
+  }
+  scalars(e, t, n, r) {
+    if (!Array.isArray(e))
+      return !1;
+    if (n < 2)
+      return !0;
+    if (Array.isArray(e)) {
+      for (let i = 0; i < e.length && i < n; i++)
+        if (!this.scalar(e[i], t, r))
+          return !1;
+    }
+    return !0;
+  }
+  mapKeys(e, t, n) {
+    let r = Object.keys(e);
+    switch (t) {
+      case c.INT32:
+      case c.FIXED32:
+      case c.SFIXED32:
+      case c.SINT32:
+      case c.UINT32:
+        return this.scalars(r.slice(0, n).map((i) => parseInt(i)), t, n);
+      case c.BOOL:
+        return this.scalars(r.slice(0, n).map((i) => i == "true" ? !0 : i == "false" ? !1 : i), t, n);
+      default:
+        return this.scalars(r, t, n, F.STRING);
+    }
+  }
+}
+function O(a, e) {
+  switch (e) {
+    case F.BIGINT:
+      return a.toBigInt();
+    case F.NUMBER:
+      return a.toNumber();
+    default:
+      return a.toString();
+  }
+}
+class st {
+  constructor(e) {
+    this.info = e;
+  }
+  prepare() {
+    var e;
+    if (this.fMap === void 0) {
+      this.fMap = {};
+      const t = (e = this.info.fields) !== null && e !== void 0 ? e : [];
+      for (const n of t)
+        this.fMap[n.name] = n, this.fMap[n.jsonName] = n, this.fMap[n.localName] = n;
+    }
+  }
+  // Cannot parse JSON <type of jsonValue> for <type name>#<fieldName>.
+  assert(e, t, n) {
+    if (!e) {
+      let r = De(n);
+      throw (r == "number" || r == "boolean") && (r = n.toString()), new Error(`Cannot parse JSON ${r} for ${this.info.typeName}#${t}`);
+    }
+  }
+  /**
+   * Reads a message from canonical JSON format into the target message.
+   *
+   * Repeated fields are appended. Map entries are added, overwriting
+   * existing keys.
+   *
+   * If a message field is already present, it will be merged with the
+   * new data.
+   */
+  read(e, t, n) {
+    this.prepare();
+    const r = [];
+    for (const [i, l] of Object.entries(e)) {
+      const s = this.fMap[i];
+      if (!s) {
+        if (!n.ignoreUnknownFields)
+          throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${i}`);
+        continue;
+      }
+      const o = s.localName;
+      let f;
+      if (s.oneof) {
+        if (l === null && (s.kind !== "enum" || s.T()[0] !== "google.protobuf.NullValue"))
+          continue;
+        if (r.includes(s.oneof))
+          throw new Error(`Multiple members of the oneof group "${s.oneof}" of ${this.info.typeName} are present in JSON.`);
+        r.push(s.oneof), f = t[s.oneof] = {
+          oneofKind: o
+        };
+      } else
+        f = t;
+      if (s.kind == "map") {
+        if (l === null)
+          continue;
+        this.assert(Pe(l), s.name, l);
+        const h = f[o];
+        for (const [g, k] of Object.entries(l)) {
+          this.assert(k !== null, s.name + " map value", null);
+          let R;
+          switch (s.V.kind) {
+            case "message":
+              R = s.V.T().internalJsonRead(k, n);
+              break;
+            case "enum":
+              if (R = this.enum(s.V.T(), k, s.name, n.ignoreUnknownFields), R === !1)
+                continue;
+              break;
+            case "scalar":
+              R = this.scalar(k, s.V.T, s.V.L, s.name);
+              break;
+          }
+          this.assert(R !== void 0, s.name + " map value", k);
+          let U = g;
+          s.K == c.BOOL && (U = U == "true" ? !0 : U == "false" ? !1 : U), U = this.scalar(U, s.K, F.STRING, s.name).toString(), h[U] = R;
+        }
+      } else if (s.repeat) {
+        if (l === null)
+          continue;
+        this.assert(Array.isArray(l), s.name, l);
+        const h = f[o];
+        for (const g of l) {
+          this.assert(g !== null, s.name, null);
+          let k;
+          switch (s.kind) {
+            case "message":
+              k = s.T().internalJsonRead(g, n);
+              break;
+            case "enum":
+              if (k = this.enum(s.T(), g, s.name, n.ignoreUnknownFields), k === !1)
+                continue;
+              break;
+            case "scalar":
+              k = this.scalar(g, s.T, s.L, s.name);
+              break;
+          }
+          this.assert(k !== void 0, s.name, l), h.push(k);
+        }
+      } else
+        switch (s.kind) {
+          case "message":
+            if (l === null && s.T().typeName != "google.protobuf.Value") {
+              this.assert(s.oneof === void 0, s.name + " (oneof member)", null);
+              continue;
+            }
+            f[o] = s.T().internalJsonRead(l, n, f[o]);
+            break;
+          case "enum":
+            if (l === null)
+              continue;
+            let h = this.enum(s.T(), l, s.name, n.ignoreUnknownFields);
+            if (h === !1)
+              continue;
+            f[o] = h;
+            break;
+          case "scalar":
+            if (l === null)
+              continue;
+            f[o] = this.scalar(l, s.T, s.L, s.name);
+            break;
+        }
+    }
+  }
+  /**
+   * Returns `false` for unrecognized string representations.
+   *
+   * google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`).
+   */
+  enum(e, t, n, r) {
+    if (e[0] == "google.protobuf.NullValue" && y(t === null || t === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${n}, enum ${e[0]} only accepts null.`), t === null)
+      return 0;
+    switch (typeof t) {
+      case "number":
+        return y(Number.isInteger(t), `Unable to parse field ${this.info.typeName}#${n}, enum can only be integral number, got ${t}.`), t;
+      case "string":
+        let i = t;
+        e[2] && t.substring(0, e[2].length) === e[2] && (i = t.substring(e[2].length));
+        let l = e[1][i];
+        return typeof l > "u" && r ? !1 : (y(typeof l == "number", `Unable to parse field ${this.info.typeName}#${n}, enum ${e[0]} has no value for "${t}".`), l);
+    }
+    y(!1, `Unable to parse field ${this.info.typeName}#${n}, cannot parse enum value from ${typeof t}".`);
+  }
+  scalar(e, t, n, r) {
+    let i;
+    try {
+      switch (t) {
+        // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+        // Either numbers or strings are accepted. Exponent notation is also accepted.
+        case c.DOUBLE:
+        case c.FLOAT:
+          if (e === null)
+            return 0;
+          if (e === "NaN")
+            return Number.NaN;
+          if (e === "Infinity")
+            return Number.POSITIVE_INFINITY;
+          if (e === "-Infinity")
+            return Number.NEGATIVE_INFINITY;
+          if (e === "") {
+            i = "empty string";
+            break;
+          }
+          if (typeof e == "string" && e.trim().length !== e.length) {
+            i = "extra whitespace";
+            break;
+          }
+          if (typeof e != "string" && typeof e != "number")
+            break;
+          let l = Number(e);
+          if (Number.isNaN(l)) {
+            i = "not a number";
+            break;
+          }
+          if (!Number.isFinite(l)) {
+            i = "too large or small";
+            break;
+          }
+          return t == c.FLOAT && ke(l), l;
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case c.INT32:
+        case c.FIXED32:
+        case c.SFIXED32:
+        case c.SINT32:
+        case c.UINT32:
+          if (e === null)
+            return 0;
+          let s;
+          if (typeof e == "number" ? s = e : e === "" ? i = "empty string" : typeof e == "string" && (e.trim().length !== e.length ? i = "extra whitespace" : s = Number(e)), s === void 0)
+            break;
+          return t == c.UINT32 ? Y(s) : _(s), s;
+        // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
+        case c.INT64:
+        case c.SFIXED64:
+        case c.SINT64:
+          if (e === null)
+            return O(N.ZERO, n);
+          if (typeof e != "number" && typeof e != "string")
+            break;
+          return O(N.from(e), n);
+        case c.FIXED64:
+        case c.UINT64:
+          if (e === null)
+            return O(B.ZERO, n);
+          if (typeof e != "number" && typeof e != "string")
+            break;
+          return O(B.from(e), n);
+        // bool:
+        case c.BOOL:
+          if (e === null)
+            return !1;
+          if (typeof e != "boolean")
+            break;
+          return e;
+        // string:
+        case c.STRING:
+          if (e === null)
+            return "";
+          if (typeof e != "string") {
+            i = "extra whitespace";
+            break;
+          }
+          try {
+            encodeURIComponent(e);
+          } catch (o) {
+            o = "invalid UTF8";
+            break;
+          }
+          return e;
+        // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+        // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+        case c.BYTES:
+          if (e === null || e === "")
+            return new Uint8Array(0);
+          if (typeof e != "string")
+            break;
+          return _e(e);
+      }
+    } catch (l) {
+      i = l.message;
+    }
+    this.assert(!1, r + (i ? " - " + i : ""), e);
+  }
+}
+class ot {
+  constructor(e) {
+    var t;
+    this.fields = (t = e.fields) !== null && t !== void 0 ? t : [];
+  }
+  /**
+   * Converts the message to a JSON object, based on the field descriptors.
+   */
+  write(e, t) {
+    const n = {}, r = e;
+    for (const i of this.fields) {
+      if (!i.oneof) {
+        let f = this.field(i, r[i.localName], t);
+        f !== void 0 && (n[t.useProtoFieldName ? i.name : i.jsonName] = f);
+        continue;
+      }
+      const l = r[i.oneof];
+      if (l.oneofKind !== i.localName)
+        continue;
+      const s = i.kind == "scalar" || i.kind == "enum" ? Object.assign(Object.assign({}, t), { emitDefaultValues: !0 }) : t;
+      let o = this.field(i, l[i.localName], s);
+      y(o !== void 0), n[t.useProtoFieldName ? i.name : i.jsonName] = o;
+    }
+    return n;
+  }
+  field(e, t, n) {
+    let r;
+    if (e.kind == "map") {
+      y(typeof t == "object" && t !== null);
+      const i = {};
+      switch (e.V.kind) {
+        case "scalar":
+          for (const [o, f] of Object.entries(t)) {
+            const h = this.scalar(e.V.T, f, e.name, !1, !0);
+            y(h !== void 0), i[o.toString()] = h;
+          }
+          break;
+        case "message":
+          const l = e.V.T();
+          for (const [o, f] of Object.entries(t)) {
+            const h = this.message(l, f, e.name, n);
+            y(h !== void 0), i[o.toString()] = h;
+          }
+          break;
+        case "enum":
+          const s = e.V.T();
+          for (const [o, f] of Object.entries(t)) {
+            y(f === void 0 || typeof f == "number");
+            const h = this.enum(s, f, e.name, !1, !0, n.enumAsInteger);
+            y(h !== void 0), i[o.toString()] = h;
+          }
+          break;
+      }
+      (n.emitDefaultValues || Object.keys(i).length > 0) && (r = i);
+    } else if (e.repeat) {
+      y(Array.isArray(t));
+      const i = [];
+      switch (e.kind) {
+        case "scalar":
+          for (let o = 0; o < t.length; o++) {
+            const f = this.scalar(e.T, t[o], e.name, e.opt, !0);
+            y(f !== void 0), i.push(f);
+          }
+          break;
+        case "enum":
+          const l = e.T();
+          for (let o = 0; o < t.length; o++) {
+            y(t[o] === void 0 || typeof t[o] == "number");
+            const f = this.enum(l, t[o], e.name, e.opt, !0, n.enumAsInteger);
+            y(f !== void 0), i.push(f);
+          }
+          break;
+        case "message":
+          const s = e.T();
+          for (let o = 0; o < t.length; o++) {
+            const f = this.message(s, t[o], e.name, n);
+            y(f !== void 0), i.push(f);
+          }
+          break;
+      }
+      (n.emitDefaultValues || i.length > 0 || n.emitDefaultValues) && (r = i);
+    } else
+      switch (e.kind) {
+        case "scalar":
+          r = this.scalar(e.T, t, e.name, e.opt, n.emitDefaultValues);
+          break;
+        case "enum":
+          r = this.enum(e.T(), t, e.name, e.opt, n.emitDefaultValues, n.enumAsInteger);
+          break;
+        case "message":
+          r = this.message(e.T(), t, e.name, n);
+          break;
+      }
+    return r;
+  }
+  /**
+   * Returns `null` as the default for google.protobuf.NullValue.
+   */
+  enum(e, t, n, r, i, l) {
+    if (e[0] == "google.protobuf.NullValue")
+      return !i && !r ? void 0 : null;
+    if (t === void 0) {
+      y(r);
+      return;
+    }
+    if (!(t === 0 && !i && !r))
+      return y(typeof t == "number"), y(Number.isInteger(t)), l || !e[1].hasOwnProperty(t) ? t : e[2] ? e[2] + e[1][t] : e[1][t];
+  }
+  message(e, t, n, r) {
+    return t === void 0 ? r.emitDefaultValues ? null : void 0 : e.internalJsonWrite(t, r);
+  }
+  scalar(e, t, n, r, i) {
+    if (t === void 0) {
+      y(r);
+      return;
+    }
+    const l = i || r;
+    switch (e) {
+      // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+      case c.INT32:
+      case c.SFIXED32:
+      case c.SINT32:
+        return t === 0 ? l ? 0 : void 0 : (_(t), t);
+      case c.FIXED32:
+      case c.UINT32:
+        return t === 0 ? l ? 0 : void 0 : (Y(t), t);
+      // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+      // Either numbers or strings are accepted. Exponent notation is also accepted.
+      case c.FLOAT:
+        ke(t);
+      case c.DOUBLE:
+        return t === 0 ? l ? 0 : void 0 : (y(typeof t == "number"), Number.isNaN(t) ? "NaN" : t === Number.POSITIVE_INFINITY ? "Infinity" : t === Number.NEGATIVE_INFINITY ? "-Infinity" : t);
+      // string:
+      case c.STRING:
+        return t === "" ? l ? "" : void 0 : (y(typeof t == "string"), t);
+      // bool:
+      case c.BOOL:
+        return t === !1 ? l ? !1 : void 0 : (y(typeof t == "boolean"), t);
+      // JSON value will be a decimal string. Either numbers or strings are accepted.
+      case c.UINT64:
+      case c.FIXED64:
+        y(typeof t == "number" || typeof t == "string" || typeof t == "bigint");
+        let s = B.from(t);
+        return s.isZero() && !l ? void 0 : s.toString();
+      // JSON value will be a decimal string. Either numbers or strings are accepted.
+      case c.INT64:
+      case c.SFIXED64:
+      case c.SINT64:
+        y(typeof t == "number" || typeof t == "string" || typeof t == "bigint");
+        let o = N.from(t);
+        return o.isZero() && !l ? void 0 : o.toString();
+      // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+      // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+      case c.BYTES:
+        return y(t instanceof Uint8Array), t.byteLength ? Se(t) : l ? "" : void 0;
+    }
+  }
+}
+function ye(a, e = F.STRING) {
+  switch (a) {
+    case c.BOOL:
+      return !1;
+    case c.UINT64:
+    case c.FIXED64:
+      return O(B.ZERO, e);
+    case c.INT64:
+    case c.SFIXED64:
+    case c.SINT64:
+      return O(N.ZERO, e);
+    case c.DOUBLE:
+    case c.FLOAT:
+      return 0;
+    case c.BYTES:
+      return new Uint8Array(0);
+    case c.STRING:
+      return "";
+    default:
+      return 0;
+  }
+}
+class lt {
+  constructor(e) {
+    this.info = e;
+  }
+  prepare() {
+    var e;
+    if (!this.fieldNoToField) {
+      const t = (e = this.info.fields) !== null && e !== void 0 ? e : [];
+      this.fieldNoToField = new Map(t.map((n) => [n.no, n]));
+    }
+  }
+  /**
+   * Reads a message from binary format into the target message.
+   *
+   * Repeated fields are appended. Map entries are added, overwriting
+   * existing keys.
+   *
+   * If a message field is already present, it will be merged with the
+   * new data.
+   */
+  read(e, t, n, r) {
+    this.prepare();
+    const i = r === void 0 ? e.len : e.pos + r;
+    for (; e.pos < i; ) {
+      const [l, s] = e.tag(), o = this.fieldNoToField.get(l);
+      if (!o) {
+        let k = n.readUnknownField;
+        if (k == "throw")
+          throw new Error(`Unknown field ${l} (wire type ${s}) for ${this.info.typeName}`);
+        let R = e.skip(s);
+        k !== !1 && (k === !0 ? d.onRead : k)(this.info.typeName, t, l, s, R);
+        continue;
+      }
+      let f = t, h = o.repeat, g = o.localName;
+      switch (o.oneof && (f = f[o.oneof], f.oneofKind !== g && (f = t[o.oneof] = {
+        oneofKind: g
+      })), o.kind) {
+        case "scalar":
+        case "enum":
+          let k = o.kind == "enum" ? c.INT32 : o.T, R = o.kind == "scalar" ? o.L : void 0;
+          if (h) {
+            let S = f[g];
+            if (s == u.LengthDelimited && k != c.STRING && k != c.BYTES) {
+              let z = e.uint32() + e.pos;
+              for (; e.pos < z; )
+                S.push(this.scalar(e, k, R));
+            } else
+              S.push(this.scalar(e, k, R));
+          } else
+            f[g] = this.scalar(e, k, R);
+          break;
+        case "message":
+          if (h) {
+            let S = f[g], z = o.T().internalBinaryRead(e, e.uint32(), n);
+            S.push(z);
+          } else
+            f[g] = o.T().internalBinaryRead(e, e.uint32(), n, f[g]);
+          break;
+        case "map":
+          let [U, Ce] = this.mapEntry(o, e, n);
+          f[g][U] = Ce;
+          break;
+      }
+    }
+  }
+  /**
+   * Read a map field, expecting key field = 1, value field = 2
+   */
+  mapEntry(e, t, n) {
+    let r = t.uint32(), i = t.pos + r, l, s;
+    for (; t.pos < i; ) {
+      let [o, f] = t.tag();
+      switch (o) {
+        case 1:
+          e.K == c.BOOL ? l = t.bool().toString() : l = this.scalar(t, e.K, F.STRING);
+          break;
+        case 2:
+          switch (e.V.kind) {
+            case "scalar":
+              s = this.scalar(t, e.V.T, e.V.L);
+              break;
+            case "enum":
+              s = t.int32();
+              break;
+            case "message":
+              s = e.V.T().internalBinaryRead(t, t.uint32(), n);
+              break;
+          }
+          break;
+        default:
+          throw new Error(`Unknown field ${o} (wire type ${f}) in map entry for ${this.info.typeName}#${e.name}`);
+      }
+    }
+    if (l === void 0) {
+      let o = ye(e.K);
+      l = e.K == c.BOOL ? o.toString() : o;
+    }
+    if (s === void 0)
+      switch (e.V.kind) {
+        case "scalar":
+          s = ye(e.V.T, e.V.L);
+          break;
+        case "enum":
+          s = 0;
+          break;
+        case "message":
+          s = e.V.T().create();
+          break;
+      }
+    return [l, s];
+  }
+  scalar(e, t, n) {
+    switch (t) {
+      case c.INT32:
+        return e.int32();
+      case c.STRING:
+        return e.string();
+      case c.BOOL:
+        return e.bool();
+      case c.DOUBLE:
+        return e.double();
+      case c.FLOAT:
+        return e.float();
+      case c.INT64:
+        return O(e.int64(), n);
+      case c.UINT64:
+        return O(e.uint64(), n);
+      case c.FIXED64:
+        return O(e.fixed64(), n);
+      case c.FIXED32:
+        return e.fixed32();
+      case c.BYTES:
+        return e.bytes();
+      case c.UINT32:
+        return e.uint32();
+      case c.SFIXED32:
+        return e.sfixed32();
+      case c.SFIXED64:
+        return O(e.sfixed64(), n);
+      case c.SINT32:
+        return e.sint32();
+      case c.SINT64:
+        return O(e.sint64(), n);
+    }
+  }
+}
+class ft {
+  constructor(e) {
+    this.info = e;
+  }
+  prepare() {
+    if (!this.fields) {
+      const e = this.info.fields ? this.info.fields.concat() : [];
+      this.fields = e.sort((t, n) => t.no - n.no);
+    }
+  }
+  /**
+   * Writes the message to binary format.
+   */
+  write(e, t, n) {
+    this.prepare();
+    for (const i of this.fields) {
+      let l, s, o = i.repeat, f = i.localName;
+      if (i.oneof) {
+        const h = e[i.oneof];
+        if (h.oneofKind !== f)
+          continue;
+        l = h[f], s = !0;
+      } else
+        l = e[f], s = !1;
+      switch (i.kind) {
+        case "scalar":
+        case "enum":
+          let h = i.kind == "enum" ? c.INT32 : i.T;
+          if (o)
+            if (y(Array.isArray(l)), o == Z.PACKED)
+              this.packed(t, h, i.no, l);
+            else
+              for (const g of l)
+                this.scalar(t, h, i.no, g, !0);
+          else l === void 0 ? y(i.opt) : this.scalar(t, h, i.no, l, s || i.opt);
+          break;
+        case "message":
+          if (o) {
+            y(Array.isArray(l));
+            for (const g of l)
+              this.message(t, n, i.T(), i.no, g);
+          } else
+            this.message(t, n, i.T(), i.no, l);
+          break;
+        case "map":
+          y(typeof l == "object" && l !== null);
+          for (const [g, k] of Object.entries(l))
+            this.mapEntry(t, n, i, g, k);
+          break;
+      }
+    }
+    let r = n.writeUnknownFields;
+    r !== !1 && (r === !0 ? d.onWrite : r)(this.info.typeName, e, t);
+  }
+  mapEntry(e, t, n, r, i) {
+    e.tag(n.no, u.LengthDelimited), e.fork();
+    let l = r;
+    switch (n.K) {
+      case c.INT32:
+      case c.FIXED32:
+      case c.UINT32:
+      case c.SFIXED32:
+      case c.SINT32:
+        l = Number.parseInt(r);
+        break;
+      case c.BOOL:
+        y(r == "true" || r == "false"), l = r == "true";
+        break;
+    }
+    switch (this.scalar(e, n.K, 1, l, !0), n.V.kind) {
+      case "scalar":
+        this.scalar(e, n.V.T, 2, i, !0);
+        break;
+      case "enum":
+        this.scalar(e, c.INT32, 2, i, !0);
+        break;
+      case "message":
+        this.message(e, t, n.V.T(), 2, i);
+        break;
+    }
+    e.join();
+  }
+  message(e, t, n, r, i) {
+    i !== void 0 && (n.internalBinaryWrite(i, e.tag(r, u.LengthDelimited).fork(), t), e.join());
+  }
+  /**
+   * Write a single scalar value.
+   */
+  scalar(e, t, n, r, i) {
+    let [l, s, o] = this.scalarInfo(t, r);
+    (!o || i) && (e.tag(n, l), e[s](r));
+  }
+  /**
+   * Write an array of scalar values in packed format.
+   */
+  packed(e, t, n, r) {
+    if (!r.length)
+      return;
+    y(t !== c.BYTES && t !== c.STRING), e.tag(n, u.LengthDelimited), e.fork();
+    let [, i] = this.scalarInfo(t);
+    for (let l = 0; l < r.length; l++)
+      e[i](r[l]);
+    e.join();
+  }
+  /**
+   * Get information for writing a scalar value.
+   *
+   * Returns tuple:
+   * [0]: appropriate WireType
+   * [1]: name of the appropriate method of IBinaryWriter
+   * [2]: whether the given value is a default value
+   *
+   * If argument `value` is omitted, [2] is always false.
+   */
+  scalarInfo(e, t) {
+    let n = u.Varint, r, i = t === void 0, l = t === 0;
+    switch (e) {
+      case c.INT32:
+        r = "int32";
+        break;
+      case c.STRING:
+        l = i || !t.length, n = u.LengthDelimited, r = "string";
+        break;
+      case c.BOOL:
+        l = t === !1, r = "bool";
+        break;
+      case c.UINT32:
+        r = "uint32";
+        break;
+      case c.DOUBLE:
+        n = u.Bit64, r = "double";
+        break;
+      case c.FLOAT:
+        n = u.Bit32, r = "float";
+        break;
+      case c.INT64:
+        l = i || N.from(t).isZero(), r = "int64";
+        break;
+      case c.UINT64:
+        l = i || B.from(t).isZero(), r = "uint64";
+        break;
+      case c.FIXED64:
+        l = i || B.from(t).isZero(), n = u.Bit64, r = "fixed64";
+        break;
+      case c.BYTES:
+        l = i || !t.byteLength, n = u.LengthDelimited, r = "bytes";
+        break;
+      case c.FIXED32:
+        n = u.Bit32, r = "fixed32";
+        break;
+      case c.SFIXED32:
+        n = u.Bit32, r = "sfixed32";
+        break;
+      case c.SFIXED64:
+        l = i || N.from(t).isZero(), n = u.Bit64, r = "sfixed64";
+        break;
+      case c.SINT32:
+        r = "sint32";
+        break;
+      case c.SINT64:
+        l = i || N.from(t).isZero(), r = "sint64";
+        break;
+    }
+    return [n, r, i || l];
+  }
+}
+function ut(a) {
+  const e = a.messagePrototype ? Object.create(a.messagePrototype) : Object.defineProperty({}, Le, { value: a });
+  for (let t of a.fields) {
+    let n = t.localName;
+    if (!t.opt)
+      if (t.oneof)
+        e[t.oneof] = { oneofKind: void 0 };
+      else if (t.repeat)
+        e[n] = [];
+      else
+        switch (t.kind) {
+          case "scalar":
+            e[n] = ye(t.T, t.L);
+            break;
+          case "enum":
+            e[n] = 0;
+            break;
+          case "map":
+            e[n] = {};
+            break;
+        }
+  }
+  return e;
+}
+function m(a, e, t) {
+  let n, r = t, i;
+  for (let l of a.fields) {
+    let s = l.localName;
+    if (l.oneof) {
+      const o = r[l.oneof];
+      if (o?.oneofKind == null)
+        continue;
+      if (n = o[s], i = e[l.oneof], i.oneofKind = o.oneofKind, n == null) {
+        delete i[s];
+        continue;
+      }
+    } else if (n = r[s], i = e, n == null)
+      continue;
+    switch (l.repeat && (i[s].length = n.length), l.kind) {
+      case "scalar":
+      case "enum":
+        if (l.repeat)
+          for (let f = 0; f < n.length; f++)
+            i[s][f] = n[f];
+        else
+          i[s] = n;
+        break;
+      case "message":
+        let o = l.T();
+        if (l.repeat)
+          for (let f = 0; f < n.length; f++)
+            i[s][f] = o.create(n[f]);
+        else i[s] === void 0 ? i[s] = o.create(n) : o.mergePartial(i[s], n);
+        break;
+      case "map":
+        switch (l.V.kind) {
+          case "scalar":
+          case "enum":
+            Object.assign(i[s], n);
+            break;
+          case "message":
+            let f = l.V.T();
+            for (let h of Object.keys(n))
+              i[s][h] = f.create(n[h]);
+            break;
+        }
+        break;
+    }
+  }
+}
+function ct(a, e, t) {
+  if (e === t)
+    return !0;
+  if (!e || !t)
+    return !1;
+  for (let n of a.fields) {
+    let r = n.localName, i = n.oneof ? e[n.oneof][r] : e[r], l = n.oneof ? t[n.oneof][r] : t[r];
+    switch (n.kind) {
+      case "enum":
+      case "scalar":
+        let s = n.kind == "enum" ? c.INT32 : n.T;
+        if (!(n.repeat ? Re(s, i, l) : Ke(s, i, l)))
+          return !1;
+        break;
+      case "map":
+        if (!(n.V.kind == "message" ? Ee(n.V.T(), X(i), X(l)) : Re(n.V.kind == "enum" ? c.INT32 : n.V.T, X(i), X(l))))
+          return !1;
+        break;
+      case "message":
+        let o = n.T();
+        if (!(n.repeat ? Ee(o, i, l) : o.equals(i, l)))
+          return !1;
+        break;
+    }
+  }
+  return !0;
+}
+const X = Object.values;
+function Ke(a, e, t) {
+  if (e === t)
+    return !0;
+  if (a !== c.BYTES)
+    return !1;
+  let n = e, r = t;
+  if (n.length !== r.length)
+    return !1;
+  for (let i = 0; i < n.length; i++)
+    if (n[i] != r[i])
+      return !1;
+  return !0;
+}
+function Re(a, e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (!Ke(a, e[n], t[n]))
+      return !1;
+  return !0;
+}
+function Ee(a, e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (!a.equals(e[n], t[n]))
+      return !1;
+  return !0;
+}
+const xe = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({})), ht = xe[Le] = {};
+class b {
+  constructor(e, t, n) {
+    this.defaultCheckDepth = 16, this.typeName = e, this.fields = t.map(it), this.options = n ?? {}, ht.value = this, this.messagePrototype = Object.create(null, xe), this.refTypeCheck = new at(this), this.refJsonReader = new st(this), this.refJsonWriter = new ot(this), this.refBinReader = new lt(this), this.refBinWriter = new ft(this);
+  }
+  create(e) {
+    let t = ut(this);
+    return e !== void 0 && m(this, t, e), t;
+  }
+  /**
+   * Clone the message.
+   *
+   * Unknown fields are discarded.
+   */
+  clone(e) {
+    let t = this.create();
+    return m(this, t, e), t;
+  }
+  /**
+   * Determines whether two message of the same type have the same field values.
+   * Checks for deep equality, traversing repeated fields, oneof groups, maps
+   * and messages recursively.
+   * Will also return true if both messages are `undefined`.
+   */
+  equals(e, t) {
+    return ct(this, e, t);
+  }
+  /**
+   * Is the given value assignable to our message type
+   * and contains no [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)?
+   */
+  is(e, t = this.defaultCheckDepth) {
+    return this.refTypeCheck.is(e, t, !1);
+  }
+  /**
+   * Is the given value assignable to our message type,
+   * regardless of [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)?
+   */
+  isAssignable(e, t = this.defaultCheckDepth) {
+    return this.refTypeCheck.is(e, t, !0);
+  }
+  /**
+   * Copy partial data into the target message.
+   */
+  mergePartial(e, t) {
+    m(this, e, t);
+  }
+  /**
+   * Create a new message from binary format.
+   */
+  fromBinary(e, t) {
+    let n = Je(t);
+    return this.internalBinaryRead(n.readerFactory(e), e.byteLength, n);
+  }
+  /**
+   * Read a new message from a JSON value.
+   */
+  fromJson(e, t) {
+    return this.internalJsonRead(e, tt(t));
+  }
+  /**
+   * Read a new message from a JSON string.
+   * This is equivalent to `T.fromJson(JSON.parse(json))`.
+   */
+  fromJsonString(e, t) {
+    let n = JSON.parse(e);
+    return this.fromJson(n, t);
+  }
+  /**
+   * Write the message to canonical JSON value.
+   */
+  toJson(e, t) {
+    return this.internalJsonWrite(e, nt(t));
+  }
+  /**
+   * Convert the message to canonical JSON string.
+   * This is equivalent to `JSON.stringify(T.toJson(t))`
+   */
+  toJsonString(e, t) {
+    var n;
+    let r = this.toJson(e, t);
+    return JSON.stringify(r, null, (n = t?.prettySpaces) !== null && n !== void 0 ? n : 0);
+  }
+  /**
+   * Write the message to binary format.
+   */
+  toBinary(e, t) {
+    let n = He(t);
+    return this.internalBinaryWrite(e, n.writerFactory(), n).finish();
+  }
+  /**
+   * This is an internal method. If you just want to read a message from
+   * JSON, use `fromJson()` or `fromJsonString()`.
+   *
+   * Reads JSON value and merges the fields into the target
+   * according to protobuf rules. If the target is omitted,
+   * a new instance is created first.
+   */
+  internalJsonRead(e, t, n) {
+    if (e !== null && typeof e == "object" && !Array.isArray(e)) {
+      let r = n ?? this.create();
+      return this.refJsonReader.read(e, r, t), r;
+    }
+    throw new Error(`Unable to parse message ${this.typeName} from JSON ${De(e)}.`);
+  }
+  /**
+   * This is an internal method. If you just want to write a message
+   * to JSON, use `toJson()` or `toJsonString().
+   *
+   * Writes JSON value and returns it.
+   */
+  internalJsonWrite(e, t) {
+    return this.refJsonWriter.write(e, t);
+  }
+  /**
+   * This is an internal method. If you just want to write a message
+   * in binary format, use `toBinary()`.
+   *
+   * Serializes the message in binary format and appends it to the given
+   * writer. Returns passed writer.
+   */
+  internalBinaryWrite(e, t, n) {
+    return this.refBinWriter.write(e, t, n), t;
+  }
+  /**
+   * This is an internal method. If you just want to read a message from
+   * binary data, use `fromBinary()`.
+   *
+   * Reads data from binary format and merges the fields into
+   * the target according to protobuf rules. If the target is
+   * omitted, a new instance is created first.
+   */
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create();
+    return this.refBinReader.read(e, i, n, t), i;
+  }
+}
+var We = /* @__PURE__ */ ((a) => (a[a.NULL_VALUE = 0] = "NULL_VALUE", a))(We || {});
+class dt extends b {
+  constructor() {
+    super("shared.Struct", [
+      { no: 1, name: "fields", kind: "map", K: 9, V: { kind: "message", T: () => I } }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.fields = {}, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* map<string, shared.Value> fields */
+        1:
+          this.binaryReadMap1(i.fields, e, n);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  binaryReadMap1(e, t, n) {
+    let r = t.uint32(), i = t.pos + r, l, s;
+    for (; t.pos < i; ) {
+      let [o, f] = t.tag();
+      switch (o) {
+        case 1:
+          l = t.string();
+          break;
+        case 2:
+          s = I.internalBinaryRead(t, t.uint32(), n);
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for shared.Struct.fields");
+      }
+    }
+    e[l ?? ""] = s ?? I.create();
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let i of globalThis.Object.keys(e.fields))
+      t.tag(1, u.LengthDelimited).fork().tag(1, u.LengthDelimited).string(i), t.tag(2, u.LengthDelimited).fork(), I.internalBinaryWrite(e.fields[i], t, n), t.join().join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const H = new dt();
+class pt extends b {
+  constructor() {
+    super("shared.Value", [
+      { no: 1, name: "null_value", kind: "enum", oneof: "kind", T: () => ["shared.NullValue", We] },
+      {
+        no: 2,
+        name: "number_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 1
+        /*ScalarType.DOUBLE*/
+      },
+      {
+        no: 3,
+        name: "string_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "bool_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 5, name: "struct_value", kind: "message", oneof: "kind", T: () => H },
+      { no: 6, name: "list_value", kind: "message", oneof: "kind", T: () => ee }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.kind = { oneofKind: void 0 }, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.NullValue null_value */
+        1:
+          i.kind = {
+            oneofKind: "nullValue",
+            nullValue: e.int32()
+          };
+          break;
+        case /* double number_value */
+        2:
+          i.kind = {
+            oneofKind: "numberValue",
+            numberValue: e.double()
+          };
+          break;
+        case /* string string_value */
+        3:
+          i.kind = {
+            oneofKind: "stringValue",
+            stringValue: e.string()
+          };
+          break;
+        case /* bool bool_value */
+        4:
+          i.kind = {
+            oneofKind: "boolValue",
+            boolValue: e.bool()
+          };
+          break;
+        case /* shared.Struct struct_value */
+        5:
+          i.kind = {
+            oneofKind: "structValue",
+            structValue: H.internalBinaryRead(e, e.uint32(), n, i.kind.structValue)
+          };
+          break;
+        case /* shared.ListValue list_value */
+        6:
+          i.kind = {
+            oneofKind: "listValue",
+            listValue: ee.internalBinaryRead(e, e.uint32(), n, i.kind.listValue)
+          };
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.kind.oneofKind === "nullValue" && t.tag(1, u.Varint).int32(e.kind.nullValue), e.kind.oneofKind === "numberValue" && t.tag(2, u.Bit64).double(e.kind.numberValue), e.kind.oneofKind === "stringValue" && t.tag(3, u.LengthDelimited).string(e.kind.stringValue), e.kind.oneofKind === "boolValue" && t.tag(4, u.Varint).bool(e.kind.boolValue), e.kind.oneofKind === "structValue" && H.internalBinaryWrite(e.kind.structValue, t.tag(5, u.LengthDelimited).fork(), n).join(), e.kind.oneofKind === "listValue" && ee.internalBinaryWrite(e.kind.listValue, t.tag(6, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const I = new pt();
+class gt extends b {
+  constructor() {
+    super("shared.ListValue", [
+      { no: 1, name: "values", kind: "message", repeat: 2, T: () => I }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.values = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* repeated shared.Value values */
+        1:
+          i.values.push(I.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let i = 0; i < e.values.length; i++)
+      I.internalBinaryWrite(e.values[i], t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ee = new gt();
+class yt extends b {
+  constructor() {
+    super("shared.Version", [
+      {
+        no: 1,
+        name: "major",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 2,
+        name: "minor",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 3,
+        name: "patch",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.major = 0, t.minor = 0, t.patch = 0, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* int32 major */
+        1:
+          i.major = e.int32();
+          break;
+        case /* int32 minor */
+        2:
+          i.minor = e.int32();
+          break;
+        case /* int32 patch */
+        3:
+          i.patch = e.int32();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.major !== 0 && t.tag(1, u.Varint).int32(e.major), e.minor !== 0 && t.tag(2, u.Varint).int32(e.minor), e.patch !== 0 && t.tag(3, u.Varint).int32(e.patch);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const x = new yt();
+class mt extends b {
+  constructor() {
+    super("shared.Translation", [
+      {
+        no: 1,
+        name: "code",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "content",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.code = "", t.content = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string code */
+        1:
+          i.code = e.string();
+          break;
+        case /* string content */
+        2:
+          i.content = e.string();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.code !== "" && t.tag(1, u.LengthDelimited).string(e.code), e.content !== "" && t.tag(2, u.LengthDelimited).string(e.content);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const p = new mt();
+var L = /* @__PURE__ */ ((a) => (a[a.UNKNOWN = 0] = "UNKNOWN", a[a.PRIMITIVE = 1] = "PRIMITIVE", a[a.TYPE = 2] = "TYPE", a[a.OBJECT = 3] = "OBJECT", a[a.DATATYPE = 4] = "DATATYPE", a[a.ARRAY = 5] = "ARRAY", a[a.ERROR = 6] = "ERROR", a[a.NODE = 7] = "NODE", a))(L || {}), v = /* @__PURE__ */ ((a) => (a[a.UNKNOWN = 0] = "UNKNOWN", a[a.AND = 1] = "AND", a[a.OR = 2] = "OR", a))(v || {});
+class kt extends b {
+  constructor() {
+    super("shared.DefinitionDataType", [
+      { no: 1, name: "variant", kind: "enum", T: () => ["shared.DefinitionDataType.Variant", L] },
+      {
+        no: 2,
+        name: "identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "name", kind: "message", repeat: 2, T: () => p },
+      { no: 4, name: "rules", kind: "message", repeat: 2, T: () => te },
+      {
+        no: 5,
+        name: "generic_keys",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 6, name: "version", kind: "message", T: () => x }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.variant = 0, t.identifier = "", t.name = [], t.rules = [], t.genericKeys = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DefinitionDataType.Variant variant */
+        1:
+          i.variant = e.int32();
+          break;
+        case /* string identifier */
+        2:
+          i.identifier = e.string();
+          break;
+        case /* repeated shared.Translation name */
+        3:
+          i.name.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.DefinitionDataTypeRule rules */
+        4:
+          i.rules.push(te.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated string generic_keys */
+        5:
+          i.genericKeys.push(e.string());
+          break;
+        case /* shared.Version version */
+        6:
+          i.version = x.internalBinaryRead(e, e.uint32(), n, i.version);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.variant !== 0 && t.tag(1, u.Varint).int32(e.variant), e.identifier !== "" && t.tag(2, u.LengthDelimited).string(e.identifier);
+    for (let i = 0; i < e.name.length; i++)
+      p.internalBinaryWrite(e.name[i], t.tag(3, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.rules.length; i++)
+      te.internalBinaryWrite(e.rules[i], t.tag(4, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.genericKeys.length; i++)
+      t.tag(5, u.LengthDelimited).string(e.genericKeys[i]);
+    e.version && x.internalBinaryWrite(e.version, t.tag(6, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const Tt = new kt();
+class bt extends b {
+  constructor() {
+    super("shared.ExecutionDataType", [
+      {
+        no: 1,
+        name: "identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "rules", kind: "message", repeat: 2, T: () => ne }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.identifier = "", t.rules = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string identifier */
+        1:
+          i.identifier = e.string();
+          break;
+        case /* repeated shared.ExecutionDataTypeRule rules */
+        2:
+          i.rules.push(ne.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.identifier !== "" && t.tag(1, u.LengthDelimited).string(e.identifier);
+    for (let i = 0; i < e.rules.length; i++)
+      ne.internalBinaryWrite(e.rules[i], t.tag(2, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+new bt();
+class wt extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeRule", [
+      { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => re },
+      { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => se },
+      { no: 3, name: "item_of_collection", kind: "message", oneof: "config", T: () => V },
+      { no: 4, name: "number_range", kind: "message", oneof: "config", T: () => A },
+      { no: 5, name: "regex", kind: "message", oneof: "config", T: () => j },
+      { no: 6, name: "input_types", kind: "message", oneof: "config", T: () => le },
+      { no: 7, name: "return_type", kind: "message", oneof: "config", T: () => ue },
+      { no: 8, name: "parent_type", kind: "message", oneof: "config", T: () => ie }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.config = { oneofKind: void 0 }, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DefinitionDataTypeContainsKeyRuleConfig contains_key */
+        1:
+          i.config = {
+            oneofKind: "containsKey",
+            containsKey: re.internalBinaryRead(e, e.uint32(), n, i.config.containsKey)
+          };
+          break;
+        case /* shared.DefinitionDataTypeContainsTypeRuleConfig contains_type */
+        2:
+          i.config = {
+            oneofKind: "containsType",
+            containsType: se.internalBinaryRead(e, e.uint32(), n, i.config.containsType)
+          };
+          break;
+        case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */
+        3:
+          i.config = {
+            oneofKind: "itemOfCollection",
+            itemOfCollection: V.internalBinaryRead(e, e.uint32(), n, i.config.itemOfCollection)
+          };
+          break;
+        case /* shared.DataTypeNumberRangeRuleConfig number_range */
+        4:
+          i.config = {
+            oneofKind: "numberRange",
+            numberRange: A.internalBinaryRead(e, e.uint32(), n, i.config.numberRange)
+          };
+          break;
+        case /* shared.DataTypeRegexRuleConfig regex */
+        5:
+          i.config = {
+            oneofKind: "regex",
+            regex: j.internalBinaryRead(e, e.uint32(), n, i.config.regex)
+          };
+          break;
+        case /* shared.DefinitionDataTypeInputTypesRuleConfig input_types */
+        6:
+          i.config = {
+            oneofKind: "inputTypes",
+            inputTypes: le.internalBinaryRead(e, e.uint32(), n, i.config.inputTypes)
+          };
+          break;
+        case /* shared.DefinitionDataTypeReturnTypeRuleConfig return_type */
+        7:
+          i.config = {
+            oneofKind: "returnType",
+            returnType: ue.internalBinaryRead(e, e.uint32(), n, i.config.returnType)
+          };
+          break;
+        case /* shared.DefinitionDataTypeParentTypeRuleConfig parent_type */
+        8:
+          i.config = {
+            oneofKind: "parentType",
+            parentType: ie.internalBinaryRead(e, e.uint32(), n, i.config.parentType)
+          };
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.config.oneofKind === "containsKey" && re.internalBinaryWrite(e.config.containsKey, t.tag(1, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "containsType" && se.internalBinaryWrite(e.config.containsType, t.tag(2, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "itemOfCollection" && V.internalBinaryWrite(e.config.itemOfCollection, t.tag(3, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "numberRange" && A.internalBinaryWrite(e.config.numberRange, t.tag(4, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "regex" && j.internalBinaryWrite(e.config.regex, t.tag(5, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "inputTypes" && le.internalBinaryWrite(e.config.inputTypes, t.tag(6, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "returnType" && ue.internalBinaryWrite(e.config.returnType, t.tag(7, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "parentType" && ie.internalBinaryWrite(e.config.parentType, t.tag(8, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const te = new wt();
+class Nt extends b {
+  constructor() {
+    super("shared.ExecutionDataTypeRule", [
+      { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => ae },
+      { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => oe },
+      { no: 3, name: "item_of_collection", kind: "message", oneof: "config", T: () => V },
+      { no: 4, name: "number_range", kind: "message", oneof: "config", T: () => A },
+      { no: 5, name: "regex", kind: "message", oneof: "config", T: () => j }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.config = { oneofKind: void 0 }, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.ExecutionDataTypeContainsKeyRuleConfig contains_key */
+        1:
+          i.config = {
+            oneofKind: "containsKey",
+            containsKey: ae.internalBinaryRead(e, e.uint32(), n, i.config.containsKey)
+          };
+          break;
+        case /* shared.ExecutionDataTypeContainsTypeRuleConfig contains_type */
+        2:
+          i.config = {
+            oneofKind: "containsType",
+            containsType: oe.internalBinaryRead(e, e.uint32(), n, i.config.containsType)
+          };
+          break;
+        case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */
+        3:
+          i.config = {
+            oneofKind: "itemOfCollection",
+            itemOfCollection: V.internalBinaryRead(e, e.uint32(), n, i.config.itemOfCollection)
+          };
+          break;
+        case /* shared.DataTypeNumberRangeRuleConfig number_range */
+        4:
+          i.config = {
+            oneofKind: "numberRange",
+            numberRange: A.internalBinaryRead(e, e.uint32(), n, i.config.numberRange)
+          };
+          break;
+        case /* shared.DataTypeRegexRuleConfig regex */
+        5:
+          i.config = {
+            oneofKind: "regex",
+            regex: j.internalBinaryRead(e, e.uint32(), n, i.config.regex)
+          };
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.config.oneofKind === "containsKey" && ae.internalBinaryWrite(e.config.containsKey, t.tag(1, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "containsType" && oe.internalBinaryWrite(e.config.containsType, t.tag(2, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "itemOfCollection" && V.internalBinaryWrite(e.config.itemOfCollection, t.tag(3, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "numberRange" && A.internalBinaryWrite(e.config.numberRange, t.tag(4, u.LengthDelimited).fork(), n).join(), e.config.oneofKind === "regex" && j.internalBinaryWrite(e.config.regex, t.tag(5, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ne = new Nt();
+class It extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeParentTypeRuleConfig", [
+      { no: 1, name: "parent_type", kind: "message", T: () => w }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DataTypeIdentifier parent_type */
+        1:
+          i.parentType = w.internalBinaryRead(e, e.uint32(), n, i.parentType);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.parentType && w.internalBinaryWrite(e.parentType, t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ie = new It();
+class Bt extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeContainsKeyRuleConfig", [
+      {
+        no: 1,
+        name: "key",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "data_type_identifier", kind: "message", T: () => w }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.key = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string key */
+        1:
+          i.key = e.string();
+          break;
+        case /* shared.DataTypeIdentifier data_type_identifier */
+        2:
+          i.dataTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.dataTypeIdentifier);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.key !== "" && t.tag(1, u.LengthDelimited).string(e.key), e.dataTypeIdentifier && w.internalBinaryWrite(e.dataTypeIdentifier, t.tag(2, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const re = new Bt();
+class Rt extends b {
+  constructor() {
+    super("shared.ExecutionDataTypeContainsKeyRuleConfig", [
+      {
+        no: 1,
+        name: "key",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "data_type_identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.key = "", t.dataTypeIdentifier = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string key */
+        1:
+          i.key = e.string();
+          break;
+        case /* string data_type_identifier */
+        2:
+          i.dataTypeIdentifier = e.string();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.key !== "" && t.tag(1, u.LengthDelimited).string(e.key), e.dataTypeIdentifier !== "" && t.tag(2, u.LengthDelimited).string(e.dataTypeIdentifier);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ae = new Rt();
+class Et extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeContainsTypeRuleConfig", [
+      { no: 1, name: "data_type_identifier", kind: "message", T: () => w }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DataTypeIdentifier data_type_identifier */
+        1:
+          i.dataTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.dataTypeIdentifier);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier && w.internalBinaryWrite(e.dataTypeIdentifier, t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const se = new Et();
+class Dt extends b {
+  constructor() {
+    super("shared.ExecutionDataTypeContainsTypeRuleConfig", [
+      {
+        no: 1,
+        name: "data_type_identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.dataTypeIdentifier = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string data_type_identifier */
+        1:
+          i.dataTypeIdentifier = e.string();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier !== "" && t.tag(1, u.LengthDelimited).string(e.dataTypeIdentifier);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const oe = new Dt();
+class Ot extends b {
+  constructor() {
+    super("shared.DataTypeItemOfCollectionRuleConfig", [
+      { no: 1, name: "items", kind: "message", repeat: 2, T: () => I }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.items = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* repeated shared.Value items */
+        1:
+          i.items.push(I.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let i = 0; i < e.items.length; i++)
+      I.internalBinaryWrite(e.items[i], t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const V = new Ot();
+class Ft extends b {
+  constructor() {
+    super("shared.DataTypeNumberRangeRuleConfig", [
+      {
+        no: 1,
+        name: "from",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "to",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "steps",
+        kind: "scalar",
+        opt: !0,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.from = 0n, t.to = 0n, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* int64 from */
+        1:
+          i.from = e.int64().toBigInt();
+          break;
+        case /* int64 to */
+        2:
+          i.to = e.int64().toBigInt();
+          break;
+        case /* optional int64 steps */
+        3:
+          i.steps = e.int64().toBigInt();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.from !== 0n && t.tag(1, u.Varint).int64(e.from), e.to !== 0n && t.tag(2, u.Varint).int64(e.to), e.steps !== void 0 && t.tag(3, u.Varint).int64(e.steps);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const A = new Ft();
+class Ut extends b {
+  constructor() {
+    super("shared.DataTypeRegexRuleConfig", [
+      {
+        no: 1,
+        name: "pattern",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.pattern = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string pattern */
+        1:
+          i.pattern = e.string();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.pattern !== "" && t.tag(1, u.LengthDelimited).string(e.pattern);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const j = new Ut();
+class $t extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeInputTypesRuleConfig", [
+      { no: 1, name: "input_types", kind: "message", repeat: 2, T: () => fe }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.inputTypes = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* repeated shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType input_types */
+        1:
+          i.inputTypes.push(fe.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let i = 0; i < e.inputTypes.length; i++)
+      fe.internalBinaryWrite(e.inputTypes[i], t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const le = new $t();
+class Lt extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType", [
+      { no: 1, name: "data_type_identifier", kind: "message", T: () => w },
+      {
+        no: 2,
+        name: "input_identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.inputIdentifier = "", e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DataTypeIdentifier data_type_identifier */
+        1:
+          i.dataTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.dataTypeIdentifier);
+          break;
+        case /* string input_identifier */
+        2:
+          i.inputIdentifier = e.string();
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier && w.internalBinaryWrite(e.dataTypeIdentifier, t.tag(1, u.LengthDelimited).fork(), n).join(), e.inputIdentifier !== "" && t.tag(2, u.LengthDelimited).string(e.inputIdentifier);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const fe = new Lt();
+class Kt extends b {
+  constructor() {
+    super("shared.DefinitionDataTypeReturnTypeRuleConfig", [
+      { no: 1, name: "data_type_identifier", kind: "message", T: () => w }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DataTypeIdentifier data_type_identifier */
+        1:
+          i.dataTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.dataTypeIdentifier);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier && w.internalBinaryWrite(e.dataTypeIdentifier, t.tag(1, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ue = new Kt();
+class xt extends b {
+  constructor() {
+    super("shared.DataTypeIdentifier", [
+      {
+        no: 1,
+        name: "data_type_identifier",
+        kind: "scalar",
+        oneof: "type",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "generic_type", kind: "message", oneof: "type", T: () => ce },
+      {
+        no: 3,
+        name: "generic_key",
+        kind: "scalar",
+        oneof: "type",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.type = { oneofKind: void 0 }, e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string data_type_identifier */
+        1:
+          i.type = {
+            oneofKind: "dataTypeIdentifier",
+            dataTypeIdentifier: e.string()
+          };
+          break;
+        case /* shared.GenericType generic_type */
+        2:
+          i.type = {
+            oneofKind: "genericType",
+            genericType: ce.internalBinaryRead(e, e.uint32(), n, i.type.genericType)
+          };
+          break;
+        case /* string generic_key */
+        3:
+          i.type = {
+            oneofKind: "genericKey",
+            genericKey: e.string()
+          };
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.type.oneofKind === "dataTypeIdentifier" && t.tag(1, u.LengthDelimited).string(e.type.dataTypeIdentifier), e.type.oneofKind === "genericType" && ce.internalBinaryWrite(e.type.genericType, t.tag(2, u.LengthDelimited).fork(), n).join(), e.type.oneofKind === "genericKey" && t.tag(3, u.LengthDelimited).string(e.type.genericKey);
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const w = new xt();
+class Wt extends b {
+  constructor() {
+    super("shared.GenericType", [
+      {
+        no: 1,
+        name: "data_type_identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "generic_mappers", kind: "message", repeat: 2, T: () => he }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.dataTypeIdentifier = "", t.genericMappers = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string data_type_identifier */
+        1:
+          i.dataTypeIdentifier = e.string();
+          break;
+        case /* repeated shared.GenericMapper generic_mappers */
+        2:
+          i.genericMappers.push(he.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier !== "" && t.tag(1, u.LengthDelimited).string(e.dataTypeIdentifier);
+    for (let i = 0; i < e.genericMappers.length; i++)
+      he.internalBinaryWrite(e.genericMappers[i], t.tag(2, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const ce = new Wt();
+class Ct extends b {
+  constructor() {
+    super("shared.GenericMapper", [
+      { no: 1, name: "source", kind: "message", repeat: 2, T: () => w },
+      {
+        no: 2,
+        name: "target",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "generic_combinations", kind: "enum", repeat: 1, T: () => ["shared.GenericMapper.GenericCombinationStrategy", v] }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.source = [], t.target = "", t.genericCombinations = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* repeated shared.DataTypeIdentifier source */
+        1:
+          i.source.push(w.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* string target */
+        2:
+          i.target = e.string();
+          break;
+        case /* repeated shared.GenericMapper.GenericCombinationStrategy generic_combinations */
+        3:
+          if (o === u.LengthDelimited)
+            for (let g = e.int32() + e.pos; e.pos < g; )
+              i.genericCombinations.push(e.int32());
+          else
+            i.genericCombinations.push(e.int32());
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    for (let i = 0; i < e.source.length; i++)
+      w.internalBinaryWrite(e.source[i], t.tag(1, u.LengthDelimited).fork(), n).join();
+    if (e.target !== "" && t.tag(2, u.LengthDelimited).string(e.target), e.genericCombinations.length) {
+      t.tag(3, u.LengthDelimited).fork();
+      for (let i = 0; i < e.genericCombinations.length; i++)
+        t.int32(e.genericCombinations[i]);
+      t.join();
+    }
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const he = new Ct();
+class Vt extends b {
+  constructor() {
+    super("shared.FlowType", [
+      {
+        no: 1,
+        name: "identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "settings", kind: "message", repeat: 2, T: () => de },
+      {
+        no: 3,
+        name: "input_type_identifier",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "return_type_identifier",
+        kind: "scalar",
+        opt: !0,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "editable",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 6, name: "name", kind: "message", repeat: 2, T: () => p },
+      { no: 7, name: "description", kind: "message", repeat: 2, T: () => p },
+      { no: 8, name: "documentation", kind: "message", repeat: 2, T: () => p },
+      { no: 9, name: "version", kind: "message", T: () => x }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.identifier = "", t.settings = [], t.editable = !1, t.name = [], t.description = [], t.documentation = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string identifier */
+        1:
+          i.identifier = e.string();
+          break;
+        case /* repeated shared.FlowTypeSetting settings */
+        2:
+          i.settings.push(de.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* optional string input_type_identifier */
+        3:
+          i.inputTypeIdentifier = e.string();
+          break;
+        case /* optional string return_type_identifier */
+        4:
+          i.returnTypeIdentifier = e.string();
+          break;
+        case /* bool editable */
+        5:
+          i.editable = e.bool();
+          break;
+        case /* repeated shared.Translation name */
+        6:
+          i.name.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation description */
+        7:
+          i.description.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation documentation */
+        8:
+          i.documentation.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* shared.Version version */
+        9:
+          i.version = x.internalBinaryRead(e, e.uint32(), n, i.version);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.identifier !== "" && t.tag(1, u.LengthDelimited).string(e.identifier);
+    for (let i = 0; i < e.settings.length; i++)
+      de.internalBinaryWrite(e.settings[i], t.tag(2, u.LengthDelimited).fork(), n).join();
+    e.inputTypeIdentifier !== void 0 && t.tag(3, u.LengthDelimited).string(e.inputTypeIdentifier), e.returnTypeIdentifier !== void 0 && t.tag(4, u.LengthDelimited).string(e.returnTypeIdentifier), e.editable !== !1 && t.tag(5, u.Varint).bool(e.editable);
+    for (let i = 0; i < e.name.length; i++)
+      p.internalBinaryWrite(e.name[i], t.tag(6, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.description.length; i++)
+      p.internalBinaryWrite(e.description[i], t.tag(7, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.documentation.length; i++)
+      p.internalBinaryWrite(e.documentation[i], t.tag(8, u.LengthDelimited).fork(), n).join();
+    e.version && x.internalBinaryWrite(e.version, t.tag(9, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const At = new Vt();
+class jt extends b {
+  constructor() {
+    super("shared.FlowTypeSetting", [
+      {
+        no: 1,
+        name: "identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "unique",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 3,
+        name: "data_type_identifier",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "default_value", kind: "message", T: () => I },
+      { no: 5, name: "name", kind: "message", repeat: 2, T: () => p },
+      { no: 6, name: "description", kind: "message", repeat: 2, T: () => p }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.identifier = "", t.unique = !1, t.dataTypeIdentifier = "", t.name = [], t.description = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string identifier */
+        1:
+          i.identifier = e.string();
+          break;
+        case /* bool unique */
+        2:
+          i.unique = e.bool();
+          break;
+        case /* string data_type_identifier */
+        3:
+          i.dataTypeIdentifier = e.string();
+          break;
+        case /* optional shared.Value default_value */
+        4:
+          i.defaultValue = I.internalBinaryRead(e, e.uint32(), n, i.defaultValue);
+          break;
+        case /* repeated shared.Translation name */
+        5:
+          i.name.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation description */
+        6:
+          i.description.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.identifier !== "" && t.tag(1, u.LengthDelimited).string(e.identifier), e.unique !== !1 && t.tag(2, u.Varint).bool(e.unique), e.dataTypeIdentifier !== "" && t.tag(3, u.LengthDelimited).string(e.dataTypeIdentifier), e.defaultValue && I.internalBinaryWrite(e.defaultValue, t.tag(4, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.name.length; i++)
+      p.internalBinaryWrite(e.name[i], t.tag(5, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.description.length; i++)
+      p.internalBinaryWrite(e.description[i], t.tag(6, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const de = new jt();
+class Pt extends b {
+  constructor() {
+    super("shared.RuntimeFunctionDefinition", [
+      {
+        no: 1,
+        name: "runtime_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "runtime_parameter_definitions", kind: "message", repeat: 2, T: () => pe },
+      { no: 3, name: "return_type_identifier", kind: "message", T: () => w },
+      {
+        no: 4,
+        name: "throws_error",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 5,
+        name: "generic_keys",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 6, name: "name", kind: "message", repeat: 2, T: () => p },
+      { no: 7, name: "description", kind: "message", repeat: 2, T: () => p },
+      { no: 8, name: "documentation", kind: "message", repeat: 2, T: () => p },
+      { no: 9, name: "deprecation_message", kind: "message", repeat: 2, T: () => p },
+      { no: 10, name: "version", kind: "message", T: () => x }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.runtimeName = "", t.runtimeParameterDefinitions = [], t.throwsError = !1, t.genericKeys = [], t.name = [], t.description = [], t.documentation = [], t.deprecationMessage = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* string runtime_name */
+        1:
+          i.runtimeName = e.string();
+          break;
+        case /* repeated shared.RuntimeParameterDefinition runtime_parameter_definitions */
+        2:
+          i.runtimeParameterDefinitions.push(pe.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* optional shared.DataTypeIdentifier return_type_identifier */
+        3:
+          i.returnTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.returnTypeIdentifier);
+          break;
+        case /* bool throws_error */
+        4:
+          i.throwsError = e.bool();
+          break;
+        case /* repeated string generic_keys */
+        5:
+          i.genericKeys.push(e.string());
+          break;
+        case /* repeated shared.Translation name */
+        6:
+          i.name.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation description */
+        7:
+          i.description.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation documentation */
+        8:
+          i.documentation.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation deprecation_message */
+        9:
+          i.deprecationMessage.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* shared.Version version */
+        10:
+          i.version = x.internalBinaryRead(e, e.uint32(), n, i.version);
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.runtimeName !== "" && t.tag(1, u.LengthDelimited).string(e.runtimeName);
+    for (let i = 0; i < e.runtimeParameterDefinitions.length; i++)
+      pe.internalBinaryWrite(e.runtimeParameterDefinitions[i], t.tag(2, u.LengthDelimited).fork(), n).join();
+    e.returnTypeIdentifier && w.internalBinaryWrite(e.returnTypeIdentifier, t.tag(3, u.LengthDelimited).fork(), n).join(), e.throwsError !== !1 && t.tag(4, u.Varint).bool(e.throwsError);
+    for (let i = 0; i < e.genericKeys.length; i++)
+      t.tag(5, u.LengthDelimited).string(e.genericKeys[i]);
+    for (let i = 0; i < e.name.length; i++)
+      p.internalBinaryWrite(e.name[i], t.tag(6, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.description.length; i++)
+      p.internalBinaryWrite(e.description[i], t.tag(7, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.documentation.length; i++)
+      p.internalBinaryWrite(e.documentation[i], t.tag(8, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.deprecationMessage.length; i++)
+      p.internalBinaryWrite(e.deprecationMessage[i], t.tag(9, u.LengthDelimited).fork(), n).join();
+    e.version && x.internalBinaryWrite(e.version, t.tag(10, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const _t = new Pt();
+class St extends b {
+  constructor() {
+    super("shared.RuntimeParameterDefinition", [
+      { no: 1, name: "data_type_identifier", kind: "message", T: () => w },
+      {
+        no: 2,
+        name: "runtime_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "default_value", kind: "message", T: () => I },
+      { no: 4, name: "name", kind: "message", repeat: 2, T: () => p },
+      { no: 5, name: "description", kind: "message", repeat: 2, T: () => p },
+      { no: 6, name: "documentation", kind: "message", repeat: 2, T: () => p }
+    ]);
+  }
+  create(e) {
+    const t = globalThis.Object.create(this.messagePrototype);
+    return t.runtimeName = "", t.name = [], t.description = [], t.documentation = [], e !== void 0 && m(this, t, e), t;
+  }
+  internalBinaryRead(e, t, n, r) {
+    let i = r ?? this.create(), l = e.pos + t;
+    for (; e.pos < l; ) {
+      let [s, o] = e.tag();
+      switch (s) {
+        case /* shared.DataTypeIdentifier data_type_identifier */
+        1:
+          i.dataTypeIdentifier = w.internalBinaryRead(e, e.uint32(), n, i.dataTypeIdentifier);
+          break;
+        case /* string runtime_name */
+        2:
+          i.runtimeName = e.string();
+          break;
+        case /* optional shared.Value default_value */
+        3:
+          i.defaultValue = I.internalBinaryRead(e, e.uint32(), n, i.defaultValue);
+          break;
+        case /* repeated shared.Translation name */
+        4:
+          i.name.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation description */
+        5:
+          i.description.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        case /* repeated shared.Translation documentation */
+        6:
+          i.documentation.push(p.internalBinaryRead(e, e.uint32(), n));
+          break;
+        default:
+          let f = n.readUnknownField;
+          if (f === "throw")
+            throw new globalThis.Error(`Unknown field ${s} (wire type ${o}) for ${this.typeName}`);
+          let h = e.skip(o);
+          f !== !1 && (f === !0 ? d.onRead : f)(this.typeName, i, s, o, h);
+      }
+    }
+    return i;
+  }
+  internalBinaryWrite(e, t, n) {
+    e.dataTypeIdentifier && w.internalBinaryWrite(e.dataTypeIdentifier, t.tag(1, u.LengthDelimited).fork(), n).join(), e.runtimeName !== "" && t.tag(2, u.LengthDelimited).string(e.runtimeName), e.defaultValue && I.internalBinaryWrite(e.defaultValue, t.tag(3, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.name.length; i++)
+      p.internalBinaryWrite(e.name[i], t.tag(4, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.description.length; i++)
+      p.internalBinaryWrite(e.description[i], t.tag(5, u.LengthDelimited).fork(), n).join();
+    for (let i = 0; i < e.documentation.length; i++)
+      p.internalBinaryWrite(e.documentation[i], t.tag(6, u.LengthDelimited).fork(), n).join();
+    let r = n.writeUnknownFields;
+    return r !== !1 && (r == !0 ? d.onWrite : r)(this.typeName, e, t), t;
+  }
+}
+const pe = new St();
+var $ = /* @__PURE__ */ ((a) => (a.ContainsKey = "CONTAINS_KEY", a.ContainsType = "CONTAINS_TYPE", a.InputType = "INPUT_TYPE", a.ItemOfCollection = "ITEM_OF_COLLECTION", a.NumberRange = "NUMBER_RANGE", a.ParentType = "PARENT_TYPE", a.Regex = "REGEX", a.ReturnType = "RETURN_TYPE", a))($ || {}), W = /* @__PURE__ */ ((a) => (a.Array = "ARRAY", a.DataType = "DATA_TYPE", a.Error = "ERROR", a.Node = "NODE", a.Object = "OBJECT", a.Primitive = "PRIMITIVE", a.Type = "TYPE", a))(W || {}), me = /* @__PURE__ */ ((a) => (a.And = "AND", a.Or = "OR", a))(me || {});
+function E(a) {
+  return {
+    count: a.length,
+    nodes: a
+  };
+}
+function P(a, e) {
+  const t = e.constructedDataTypes.find((n) => n.identifier === a);
+  if (t == null) {
+    const n = e.scannedTucanaTypes.find((i) => i.identifier === a);
+    if (n == null)
+      return console.error("Skipping Identifier because it can't be identified:" + a), null;
+    const r = {
+      id: `gid://sagittarius/DataType/${D(e)}`,
+      genericKeys: n.genericKeys,
+      identifier: n.identifier,
+      name: E(n.name),
+      rules: Mt(n.rules, e),
+      variant: Xt(n.variant)
+    };
+    return e.constructedDataTypes.push(r), r;
+  }
+  return t;
+}
+function Mt(a, e) {
+  return {
+    count: a.length,
+    nodes: a.map(
+      (t) => {
+        switch (t.config.oneofKind) {
+          case "containsType": {
+            const n = {
+              dataTypeIdentifier: C(t.config.containsType.dataTypeIdentifier, e)
+            };
+            return {
+              variant: $.ContainsType,
+              config: n
+            };
+          }
+          case "containsKey": {
+            const n = {
+              dataTypeIdentifier: C(t.config.containsKey.dataTypeIdentifier, e),
+              key: t.config.containsKey.key
+            };
+            return {
+              variant: $.ContainsKey,
+              config: n
+            };
+          }
+          case "itemOfCollection": {
+            const n = {
+              items: t.config.itemOfCollection.items
+              //TODO: This needs to be checked
+            };
+            return {
+              variant: $.ItemOfCollection,
+              config: n
+            };
+          }
+          case "numberRange": {
+            const n = {
+              from: Number(t.config.numberRange.from),
+              steps: t.config.numberRange.steps ? Number(t.config.numberRange.steps) : void 0,
+              to: Number(t.config.numberRange.to)
+            };
+            return {
+              variant: $.NumberRange,
+              config: n
+            };
+          }
+          case "regex": {
+            const n = {
+              pattern: t.config.regex.pattern
+            };
+            return {
+              variant: $.Regex,
+              config: n
+            };
+          }
+          case "inputTypes": {
+            const n = {
+              inputTypes: t.config.inputTypes.inputTypes.map((i) => (console.log("AF: " + i.inputIdentifier), {
+                dataTypeIdentifier: C(i.dataTypeIdentifier, e),
+                inputIdentifier: i.inputIdentifier
+              }))
+            };
+            return {
+              variant: $.InputType,
+              config: n
+            };
+          }
+          case "returnType": {
+            const n = {
+              dataTypeIdentifier: C(t.config.returnType.dataTypeIdentifier, e)
+            };
+            return {
+              variant: $.ReturnType,
+              config: n
+            };
+          }
+          case "parentType": {
+            const n = {
+              dataTypeIdentifier: C(t.config.parentType.parentType, e)
+            };
+            return {
+              variant: $.ParentType,
+              config: n
+            };
+          }
+        }
+        throw new Error(`Unknown rule: ${a}`);
+      }
+    )
+  };
+}
+function Xt(a) {
+  switch (a) {
+    case L.ARRAY:
+      return W.Array;
+    case L.DATATYPE:
+      return W.DataType;
+    case L.ERROR:
+      return W.Error;
+    case L.NODE:
+      return W.Node;
+    case L.OBJECT:
+      return W.Object;
+    case L.PRIMITIVE:
+      return W.Primitive;
+    case L.TYPE:
+      return W.Type;
+    default:
+      throw new Error(`Unknown variant: ${a}`);
+  }
+}
+function C(a, e) {
+  if (a == null)
+    return null;
+  switch (a.type.oneofKind) {
+    case "genericType":
+      return {
+        id: `gid://sagittarius/DataTypeIdentifier/${D(e)}`,
+        genericType: {
+          id: `gid://sagittarius/GenericType/${D(e)}`,
+          dataType: P(a.type.genericType.dataTypeIdentifier, e),
+          genericMappers: a.type.genericType.genericMappers.map((t) => ({
+            genericCombinationStrategies: t.genericCombinations.map((n) => {
+              let r;
+              switch (n) {
+                case v.AND:
+                  r = me.And;
+                  break;
+                case v.OR:
+                  r = me.Or;
+                  break;
+                default:
+                  throw new Error("GenericCombinationStrategy was Unknown");
+              }
+              return {
+                id: `gid://sagittarius/GenericCombinationStrategy/${D(e)}`,
+                type: r
+              };
+            }),
+            sources: t.source.map(
+              (n) => C(n, e)
+            ).filter((n) => n != null),
+            target: t.target,
+            id: `gid://sagittarius/GenericMapper/${D(e)}`
+          }))
+        }
+      };
+    case "dataTypeIdentifier":
+      return {
+        id: `gid://sagittarius/DataTypeIdentifier/${D(e)}`,
+        dataType: P(a.type.dataTypeIdentifier, e)
+      };
+    case "genericKey":
+      return {
+        id: `gid://sagittarius/DataTypeIdentifier/${D(e)}`,
+        genericKey: a.type.genericKey
+      };
+  }
+  return null;
+}
+function Gt(a, e) {
+  return {
+    id: `gid://sagittarius/TypesFlowType/${D(e)}`,
+    identifier: a.identifier,
+    inputType: P(a.inputTypeIdentifier, e),
+    returnType: P(a.returnTypeIdentifier, e),
+    flowTypeSettings: Jt(a.settings, e),
+    names: E(a.name),
+    descriptions: E(a.description),
+    editable: a.editable
+  };
+}
+function Jt(a, e) {
+  return a.map((t) => ({
+    id: `gid://sagittarius/FlowTypeSetting/${D(e)}`,
+    names: E(t.name),
+    descriptions: E(t.description),
+    dataType: P(t.dataTypeIdentifier, e),
+    identifier: t.identifier,
+    unique: t.unique
+  }));
+}
+function Yt(a, e) {
+  return {
+    id: `gid://sagittarius/FunctionDefinition/${D(e)}`,
+    genericKeys: a.genericKeys,
+    names: E(a.name),
+    descriptions: E(a.description),
+    documentations: E(a.documentation),
+    deprecationMessages: E(a.deprecationMessage),
+    throwsError: a.throwsError,
+    returnType: C(a.returnTypeIdentifier, e),
+    parameterDefinitions: Zt(a.runtimeParameterDefinitions, e)
+  };
+}
+function Zt(a, e) {
+  return {
+    count: a.length,
+    nodes: a.map((t) => ({
+      id: `gid://sagittarius/ParameterDefinition/${D(e)}`,
+      names: E(t.name),
+      descriptions: E(t.description),
+      documentations: E(t.documentation),
+      dataType: C(t.dataTypeIdentifier, e)
+    }))
+  };
+}
+function D(a) {
+  const e = a.id;
+  return a.id += 1, e;
+}
+const zt = (a) => {
+  const e = [], t = [], n = [];
+  Ve(a, { withFileTypes: !0 }).forEach((s) => {
+    const o = s.name.split("_")[0];
+    if (o == null)
+      throw new Error("Feature name is null");
+    const f = je.join(s.parentPath, s.name), h = Ae(f);
+    if (s.name.includes("data_type")) {
+      const g = Tt.fromBinary(h);
+      e.push(
+        {
+          feature: o,
+          type: g
+        }
+      );
+    }
+    if (s.name.includes("function")) {
+      const g = _t.fromBinary(h);
+      t.push(
+        {
+          feature: o,
+          func: g
+        }
+      );
+    }
+    if (s.name.includes("flow_type")) {
+      const g = At.fromBinary(h);
+      n.push(
+        {
+          feature: o,
+          flow: g
+        }
+      );
+    }
+  });
+  const r = [], i = {
+    scannedTucanaTypes: e.map((s) => s.type),
+    constructedDataTypes: [],
+    id: 0
+  };
+  function l(s) {
+    const o = r.find((h) => h.name === s);
+    if (o != null)
+      return o;
+    const f = {
+      name: s,
+      dataTypes: [],
+      flowTypes: [],
+      runtimeFunctions: []
+    };
+    return r.push(f), f;
+  }
+  return e.map((s) => ({
+    name: s.feature,
+    type: P(s.type.identifier, i)
+  })).forEach((s) => {
+    s.type != null && l(s.name).dataTypes.push(s.type);
+  }), t.map((s) => ({
+    name: s.feature,
+    type: Yt(s.func, i)
+  })).forEach((s) => {
+    s.type != null && l(s.name).runtimeFunctions.push(s.type);
+  }), n.map((s) => ({
+    name: s.feature,
+    type: Gt(s.flow, i)
+  })).forEach((s) => {
+    s.type != null && l(s.name).flowTypes.push(s.type);
+  }), r;
+};
+export {
+  zt as Definition
+};