@permguard/permguard 0.0.9

package/dist/index.js

@@ -0,0 +1,4614 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AZAtomicRequestBuilder: () => AZAtomicRequestBuilder,
+  AZClient: () => AZClient,
+  AZRequestBuilder: () => AZRequestBuilder,
+  ActionBuilder: () => ActionBuilder,
+  ActorType: () => ActorType,
+  ContextBuilder: () => ContextBuilder,
+  EvaluationBuilder: () => EvaluationBuilder,
+  PrincipalBuilder: () => PrincipalBuilder,
+  ResourceBuilder: () => ResourceBuilder,
+  SubjectBuilder: () => SubjectBuilder,
+  withEndpoint: () => withEndpoint
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/azconfig.ts
+function withEndpoint(endpoint, port) {
+  return (config) => {
+    config.pdpEndpoint = {
+      endpoint,
+      port
+    };
+  };
+}
+
+// src/internal/az/azreq/grpc/v1/generated/proto/v1/pdp.ts
+var import_runtime_rpc = require("@protobuf-ts/runtime-rpc");
+
+// node_modules/@protobuf-ts/runtime/build/es2015/json-typings.js
+function typeofJsonValue(value) {
+  let t = typeof value;
+  if (t == "object") {
+    if (Array.isArray(value))
+      return "array";
+    if (value === null)
+      return "null";
+  }
+  return t;
+}
+function isJsonObject(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value);
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/base64.js
+var encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+var decTable = [];
+for (let i = 0; i < encTable.length; i++)
+  decTable[encTable[i].charCodeAt(0)] = i;
+decTable["-".charCodeAt(0)] = encTable.indexOf("+");
+decTable["_".charCodeAt(0)] = encTable.indexOf("/");
+function base64decode(base64Str) {
+  let es = base64Str.length * 3 / 4;
+  if (base64Str[base64Str.length - 2] == "=")
+    es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=")
+    es -= 1;
+  let bytes = new Uint8Array(es), bytePos = 0, groupPos = 0, b, p = 0;
+  for (let i = 0; i < base64Str.length; i++) {
+    b = decTable[base64Str.charCodeAt(i)];
+    if (b === void 0) {
+      switch (base64Str[i]) {
+        case "=":
+          groupPos = 0;
+        // reset state when padding found
+        case "\n":
+        case "\r":
+        case "	":
+        case " ":
+          continue;
+        // skip white-space, and padding
+        default:
+          throw Error(`invalid base64 string.`);
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = p << 2 | (b & 48) >> 4;
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = (p & 3) << 6 | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1)
+    throw Error(`invalid base64 string.`);
+  return bytes.subarray(0, bytePos);
+}
+function base64encode(bytes) {
+  let base64 = "", groupPos = 0, b, p = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    b = bytes[i];
+    switch (groupPos) {
+      case 0:
+        base64 += encTable[b >> 2];
+        p = (b & 3) << 4;
+        groupPos = 1;
+        break;
+      case 1:
+        base64 += encTable[p | b >> 4];
+        p = (b & 15) << 2;
+        groupPos = 2;
+        break;
+      case 2:
+        base64 += encTable[p | b >> 6];
+        base64 += encTable[b & 63];
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos) {
+    base64 += encTable[p];
+    base64 += "=";
+    if (groupPos == 1)
+      base64 += "=";
+  }
+  return base64;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/binary-format-contract.js
+var UnknownFieldHandler;
+(function(UnknownFieldHandler2) {
+  UnknownFieldHandler2.symbol = Symbol.for("protobuf-ts/unknown");
+  UnknownFieldHandler2.onRead = (typeName, message, fieldNo, wireType, data) => {
+    let container = is(message) ? message[UnknownFieldHandler2.symbol] : message[UnknownFieldHandler2.symbol] = [];
+    container.push({ no: fieldNo, wireType, data });
+  };
+  UnknownFieldHandler2.onWrite = (typeName, message, writer) => {
+    for (let { no, wireType, data } of UnknownFieldHandler2.list(message))
+      writer.tag(no, wireType).raw(data);
+  };
+  UnknownFieldHandler2.list = (message, fieldNo) => {
+    if (is(message)) {
+      let all = message[UnknownFieldHandler2.symbol];
+      return fieldNo ? all.filter((uf) => uf.no == fieldNo) : all;
+    }
+    return [];
+  };
+  UnknownFieldHandler2.last = (message, fieldNo) => UnknownFieldHandler2.list(message, fieldNo).slice(-1)[0];
+  const is = (message) => message && Array.isArray(message[UnknownFieldHandler2.symbol]);
+})(UnknownFieldHandler || (UnknownFieldHandler = {}));
+var WireType;
+(function(WireType2) {
+  WireType2[WireType2["Varint"] = 0] = "Varint";
+  WireType2[WireType2["Bit64"] = 1] = "Bit64";
+  WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
+  WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
+  WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
+  WireType2[WireType2["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+
+// node_modules/@protobuf-ts/runtime/build/es2015/goog-varint.js
+function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  lowBits |= (middleByte & 15) << 28;
+  highBits = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+function varint64write(lo, hi, bytes) {
+  for (let i = 0; i < 28; i = i + 7) {
+    const shift = lo >>> i;
+    const hasNext = !(shift >>> 7 == 0 && hi == 0);
+    const byte = (hasNext ? shift | 128 : shift) & 255;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
+  const hasMoreBits = !(hi >> 3 == 0);
+  bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
+  if (!hasMoreBits) {
+    return;
+  }
+  for (let i = 3; i < 31; i = i + 7) {
+    const shift = hi >>> i;
+    const hasNext = !(shift >>> 7 == 0);
+    const byte = (hasNext ? shift | 128 : shift) & 255;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  bytes.push(hi >>> 31 & 1);
+}
+var TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
+function int64fromString(dec) {
+  let minus = dec[0] == "-";
+  if (minus)
+    dec = dec.slice(1);
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return [minus, lowBits, highBits];
+}
+function int64toString(bitsLow, bitsHigh) {
+  if (bitsHigh >>> 0 <= 2097151) {
+    return "" + (TWO_PWR_32_DBL * bitsHigh + (bitsLow >>> 0));
+  }
+  let low = bitsLow & 16777215;
+  let mid = (bitsLow >>> 24 | bitsHigh << 8) >>> 0 & 16777215;
+  let high = bitsHigh >> 16 & 65535;
+  let digitA = low + mid * 6777216 + high * 6710656;
+  let digitB = mid + high * 8147497;
+  let digitC = high * 2;
+  let base = 1e7;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    digitC += Math.floor(digitB / base);
+    digitB %= base;
+  }
+  function decimalFrom1e7(digit1e7, needLeadingZeros) {
+    let partial = digit1e7 ? String(digit1e7) : "";
+    if (needLeadingZeros) {
+      return "0000000".slice(partial.length) + partial;
+    }
+    return partial;
+  }
+  return decimalFrom1e7(
+    digitC,
+    /*needLeadingZeros=*/
+    0
+  ) + decimalFrom1e7(
+    digitB,
+    /*needLeadingZeros=*/
+    digitC
+  ) + // If the final 1e7 digit didn't need leading zeros, we would have
+  // returned via the trivial code path at the top.
+  decimalFrom1e7(
+    digitA,
+    /*needLeadingZeros=*/
+    1
+  );
+}
+function varint32write(value, bytes) {
+  if (value >= 0) {
+    while (value > 127) {
+      bytes.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    bytes.push(value);
+  } else {
+    for (let i = 0; i < 9; i++) {
+      bytes.push(value & 127 | 128);
+      value = value >> 7;
+    }
+    bytes.push(1);
+  }
+}
+function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 127;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) != 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/pb-long.js
+var BI;
+function detectBi() {
+  const dv = new DataView(new ArrayBuffer(8));
+  const ok = globalThis.BigInt !== void 0 && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function";
+  BI = ok ? {
+    MIN: BigInt("-9223372036854775808"),
+    MAX: BigInt("9223372036854775807"),
+    UMIN: BigInt("0"),
+    UMAX: BigInt("18446744073709551615"),
+    C: BigInt,
+    V: dv
+  } : void 0;
+}
+detectBi();
+function assertBi(bi) {
+  if (!bi)
+    throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support");
+}
+var RE_DECIMAL_STR = /^-?[0-9]+$/;
+var TWO_PWR_32_DBL2 = 4294967296;
+var HALF_2_PWR_32 = 2147483648;
+var SharedPbLong = class {
+  /**
+   * Create a new instance with the given bits.
+   */
+  constructor(lo, hi) {
+    this.lo = lo | 0;
+    this.hi = hi | 0;
+  }
+  /**
+   * Is this instance equal to 0?
+   */
+  isZero() {
+    return this.lo == 0 && this.hi == 0;
+  }
+  /**
+   * Convert to a native number.
+   */
+  toNumber() {
+    let result = this.hi * TWO_PWR_32_DBL2 + (this.lo >>> 0);
+    if (!Number.isSafeInteger(result))
+      throw new Error("cannot convert to safe number");
+    return result;
+  }
+};
+var PbULong = class _PbULong extends SharedPbLong {
+  /**
+   * Create instance from a `string`, `number` or `bigint`.
+   */
+  static from(value) {
+    if (BI)
+      switch (typeof value) {
+        case "string":
+          if (value == "0")
+            return this.ZERO;
+          if (value == "")
+            throw new Error("string is no integer");
+          value = BI.C(value);
+        case "number":
+          if (value === 0)
+            return this.ZERO;
+          value = BI.C(value);
+        case "bigint":
+          if (!value)
+            return this.ZERO;
+          if (value < BI.UMIN)
+            throw new Error("signed value for ulong");
+          if (value > BI.UMAX)
+            throw new Error("ulong too large");
+          BI.V.setBigUint64(0, value, true);
+          return new _PbULong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
+      }
+    else
+      switch (typeof value) {
+        case "string":
+          if (value == "0")
+            return this.ZERO;
+          value = value.trim();
+          if (!RE_DECIMAL_STR.test(value))
+            throw new Error("string is no integer");
+          let [minus, lo, hi] = int64fromString(value);
+          if (minus)
+            throw new Error("signed value for ulong");
+          return new _PbULong(lo, hi);
+        case "number":
+          if (value == 0)
+            return this.ZERO;
+          if (!Number.isSafeInteger(value))
+            throw new Error("number is no integer");
+          if (value < 0)
+            throw new Error("signed value for ulong");
+          return new _PbULong(value, value / TWO_PWR_32_DBL2);
+      }
+    throw new Error("unknown value " + typeof value);
+  }
+  /**
+   * Convert to decimal string.
+   */
+  toString() {
+    return BI ? this.toBigInt().toString() : int64toString(this.lo, this.hi);
+  }
+  /**
+   * Convert to native bigint.
+   */
+  toBigInt() {
+    assertBi(BI);
+    BI.V.setInt32(0, this.lo, true);
+    BI.V.setInt32(4, this.hi, true);
+    return BI.V.getBigUint64(0, true);
+  }
+};
+PbULong.ZERO = new PbULong(0, 0);
+var PbLong = class _PbLong extends SharedPbLong {
+  /**
+   * Create instance from a `string`, `number` or `bigint`.
+   */
+  static from(value) {
+    if (BI)
+      switch (typeof value) {
+        case "string":
+          if (value == "0")
+            return this.ZERO;
+          if (value == "")
+            throw new Error("string is no integer");
+          value = BI.C(value);
+        case "number":
+          if (value === 0)
+            return this.ZERO;
+          value = BI.C(value);
+        case "bigint":
+          if (!value)
+            return this.ZERO;
+          if (value < BI.MIN)
+            throw new Error("signed long too small");
+          if (value > BI.MAX)
+            throw new Error("signed long too large");
+          BI.V.setBigInt64(0, value, true);
+          return new _PbLong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
+      }
+    else
+      switch (typeof value) {
+        case "string":
+          if (value == "0")
+            return this.ZERO;
+          value = value.trim();
+          if (!RE_DECIMAL_STR.test(value))
+            throw new Error("string is no integer");
+          let [minus, lo, hi] = int64fromString(value);
+          if (minus) {
+            if (hi > HALF_2_PWR_32 || hi == HALF_2_PWR_32 && lo != 0)
+              throw new Error("signed long too small");
+          } else if (hi >= HALF_2_PWR_32)
+            throw new Error("signed long too large");
+          let pbl = new _PbLong(lo, hi);
+          return minus ? pbl.negate() : pbl;
+        case "number":
+          if (value == 0)
+            return this.ZERO;
+          if (!Number.isSafeInteger(value))
+            throw new Error("number is no integer");
+          return value > 0 ? new _PbLong(value, value / TWO_PWR_32_DBL2) : new _PbLong(-value, -value / TWO_PWR_32_DBL2).negate();
+      }
+    throw new Error("unknown value " + typeof value);
+  }
+  /**
+   * Do we have a minus sign?
+   */
+  isNegative() {
+    return (this.hi & HALF_2_PWR_32) !== 0;
+  }
+  /**
+   * Negate two's complement.
+   * Invert all the bits and add one to the result.
+   */
+  negate() {
+    let hi = ~this.hi, lo = this.lo;
+    if (lo)
+      lo = ~lo + 1;
+    else
+      hi += 1;
+    return new _PbLong(lo, hi);
+  }
+  /**
+   * Convert to decimal string.
+   */
+  toString() {
+    if (BI)
+      return this.toBigInt().toString();
+    if (this.isNegative()) {
+      let n = this.negate();
+      return "-" + int64toString(n.lo, n.hi);
+    }
+    return int64toString(this.lo, this.hi);
+  }
+  /**
+   * Convert to native bigint.
+   */
+  toBigInt() {
+    assertBi(BI);
+    BI.V.setInt32(0, this.lo, true);
+    BI.V.setInt32(4, this.hi, true);
+    return BI.V.getBigInt64(0, true);
+  }
+};
+PbLong.ZERO = new PbLong(0, 0);
+
+// node_modules/@protobuf-ts/runtime/build/es2015/binary-reader.js
+var defaultsRead = {
+  readUnknownField: true,
+  readerFactory: (bytes) => new BinaryReader(bytes)
+};
+function binaryReadOptions(options) {
+  return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead;
+}
+var BinaryReader = class {
+  constructor(buf, textDecoder) {
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    this.textDecoder = textDecoder !== null && textDecoder !== void 0 ? textDecoder : new TextDecoder("utf-8", {
+      fatal: true,
+      ignoreBOM: true
+    });
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    return [fieldNo, wireType];
+  }
+  /**
+   * Skip one element on the wire and return the skipped data.
+   * Supports WireType.StartGroup since v2.0.0-alpha.23.
+   */
+  skip(wireType) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        let t;
+        while ((t = this.tag()[1]) !== WireType.EndGroup) {
+          this.skip(t);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, 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 zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return new PbLong(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return new PbULong(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [lo, hi] = this.varint64();
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return new PbLong(lo, hi);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return new PbULong(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return new PbLong(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let len = this.uint32();
+    let start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.textDecoder.decode(this.bytes());
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/assert.js
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+var FLOAT32_MAX = 34028234663852886e22;
+var FLOAT32_MIN = -34028234663852886e22;
+var UINT32_MAX = 4294967295;
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
+function assertInt32(arg) {
+  if (typeof arg !== "number")
+    throw new Error("invalid int 32: " + typeof arg);
+  if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
+    throw new Error("invalid int 32: " + arg);
+}
+function assertUInt32(arg) {
+  if (typeof arg !== "number")
+    throw new Error("invalid uint 32: " + typeof arg);
+  if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
+    throw new Error("invalid uint 32: " + arg);
+}
+function assertFloat32(arg) {
+  if (typeof arg !== "number")
+    throw new Error("invalid float 32: " + typeof arg);
+  if (!Number.isFinite(arg))
+    return;
+  if (arg > FLOAT32_MAX || arg < FLOAT32_MIN)
+    throw new Error("invalid float 32: " + arg);
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/binary-writer.js
+var defaultsWrite = {
+  writeUnknownFields: true,
+  writerFactory: () => new BinaryWriter()
+};
+function binaryWriteOptions(options) {
+  return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite;
+}
+var BinaryWriter = class {
+  constructor(textEncoder) {
+    this.stack = [];
+    this.textEncoder = textEncoder !== null && textEncoder !== void 0 ? textEncoder : new TextEncoder();
+    this.chunks = [];
+    this.buf = [];
+  }
+  /**
+   * Return all bytes written and reset this writer.
+   */
+  finish() {
+    this.chunks.push(new Uint8Array(this.buf));
+    let len = 0;
+    for (let i = 0; i < this.chunks.length; i++)
+      len += this.chunks[i].length;
+    let bytes = new Uint8Array(len);
+    let offset = 0;
+    for (let i = 0; i < this.chunks.length; i++) {
+      bytes.set(this.chunks[i], offset);
+      offset += this.chunks[i].length;
+    }
+    this.chunks = [];
+    return bytes;
+  }
+  /**
+   * Start a new fork for length-delimited data like a message
+   * or a packed repeated field.
+   *
+   * Must be joined later with `join()`.
+   */
+  fork() {
+    this.stack.push({ chunks: this.chunks, buf: this.buf });
+    this.chunks = [];
+    this.buf = [];
+    return this;
+  }
+  /**
+   * Join the last fork. Write its length and bytes, then
+   * return to the previous state.
+   */
+  join() {
+    let chunk = this.finish();
+    let prev = this.stack.pop();
+    if (!prev)
+      throw new Error("invalid state, fork stack empty");
+    this.chunks = prev.chunks;
+    this.buf = prev.buf;
+    this.uint32(chunk.byteLength);
+    return this.raw(chunk);
+  }
+  /**
+   * 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(fieldNo, type) {
+    return this.uint32((fieldNo << 3 | type) >>> 0);
+  }
+  /**
+   * Write a chunk of raw bytes.
+   */
+  raw(chunk) {
+    if (this.buf.length) {
+      this.chunks.push(new Uint8Array(this.buf));
+      this.buf = [];
+    }
+    this.chunks.push(chunk);
+    return this;
+  }
+  /**
+   * Write a `uint32` value, an unsigned 32 bit varint.
+   */
+  uint32(value) {
+    assertUInt32(value);
+    while (value > 127) {
+      this.buf.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    this.buf.push(value);
+    return this;
+  }
+  /**
+   * Write a `int32` value, a signed 32 bit varint.
+   */
+  int32(value) {
+    assertInt32(value);
+    varint32write(value, this.buf);
+    return this;
+  }
+  /**
+   * Write a `bool` value, a variant.
+   */
+  bool(value) {
+    this.buf.push(value ? 1 : 0);
+    return this;
+  }
+  /**
+   * Write a `bytes` value, length-delimited arbitrary data.
+   */
+  bytes(value) {
+    this.uint32(value.byteLength);
+    return this.raw(value);
+  }
+  /**
+   * Write a `string` value, length-delimited data converted to UTF-8 text.
+   */
+  string(value) {
+    let chunk = this.textEncoder.encode(value);
+    this.uint32(chunk.byteLength);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `float` value, 32-bit floating point number.
+   */
+  float(value) {
+    assertFloat32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setFloat32(0, value, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `double` value, a 64-bit floating point number.
+   */
+  double(value) {
+    let chunk = new Uint8Array(8);
+    new DataView(chunk.buffer).setFloat64(0, value, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(value) {
+    assertUInt32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setUint32(0, value, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(value) {
+    assertInt32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setInt32(0, value, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(value) {
+    assertInt32(value);
+    value = (value << 1 ^ value >> 31) >>> 0;
+    varint32write(value, this.buf);
+    return this;
+  }
+  /**
+   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(value) {
+    let chunk = new Uint8Array(8);
+    let view = new DataView(chunk.buffer);
+    let long = PbLong.from(value);
+    view.setInt32(0, long.lo, true);
+    view.setInt32(4, long.hi, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(value) {
+    let chunk = new Uint8Array(8);
+    let view = new DataView(chunk.buffer);
+    let long = PbULong.from(value);
+    view.setInt32(0, long.lo, true);
+    view.setInt32(4, long.hi, true);
+    return this.raw(chunk);
+  }
+  /**
+   * Write a `int64` value, a signed 64-bit varint.
+   */
+  int64(value) {
+    let long = PbLong.from(value);
+    varint64write(long.lo, long.hi, this.buf);
+    return this;
+  }
+  /**
+   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(value) {
+    let long = PbLong.from(value), sign = long.hi >> 31, lo = long.lo << 1 ^ sign, hi = (long.hi << 1 | long.lo >>> 31) ^ sign;
+    varint64write(lo, hi, this.buf);
+    return this;
+  }
+  /**
+   * Write a `uint64` value, an unsigned 64-bit varint.
+   */
+  uint64(value) {
+    let long = PbULong.from(value);
+    varint64write(long.lo, long.hi, this.buf);
+    return this;
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/json-format-contract.js
+var defaultsWrite2 = {
+  emitDefaultValues: false,
+  enumAsInteger: false,
+  useProtoFieldName: false,
+  prettySpaces: 0
+};
+var defaultsRead2 = {
+  ignoreUnknownFields: false
+};
+function jsonReadOptions(options) {
+  return options ? Object.assign(Object.assign({}, defaultsRead2), options) : defaultsRead2;
+}
+function jsonWriteOptions(options) {
+  return options ? Object.assign(Object.assign({}, defaultsWrite2), options) : defaultsWrite2;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/message-type-contract.js
+var MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type");
+
+// node_modules/@protobuf-ts/runtime/build/es2015/lower-camel-case.js
+function lowerCamelCase(snakeCase) {
+  let capNext = false;
+  const sb = [];
+  for (let i = 0; i < snakeCase.length; i++) {
+    let next = snakeCase.charAt(i);
+    if (next == "_") {
+      capNext = true;
+    } else if (/\d/.test(next)) {
+      sb.push(next);
+      capNext = true;
+    } else if (capNext) {
+      sb.push(next.toUpperCase());
+      capNext = false;
+    } else if (i == 0) {
+      sb.push(next.toLowerCase());
+    } else {
+      sb.push(next);
+    }
+  }
+  return sb.join("");
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-info.js
+var ScalarType;
+(function(ScalarType2) {
+  ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
+  ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
+  ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
+  ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
+  ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
+  ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
+  ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
+  ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
+  ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
+  ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
+  ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
+  ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
+  ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
+  ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
+  ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
+})(ScalarType || (ScalarType = {}));
+var LongType;
+(function(LongType2) {
+  LongType2[LongType2["BIGINT"] = 0] = "BIGINT";
+  LongType2[LongType2["STRING"] = 1] = "STRING";
+  LongType2[LongType2["NUMBER"] = 2] = "NUMBER";
+})(LongType || (LongType = {}));
+var RepeatType;
+(function(RepeatType2) {
+  RepeatType2[RepeatType2["NO"] = 0] = "NO";
+  RepeatType2[RepeatType2["PACKED"] = 1] = "PACKED";
+  RepeatType2[RepeatType2["UNPACKED"] = 2] = "UNPACKED";
+})(RepeatType || (RepeatType = {}));
+function normalizeFieldInfo(field) {
+  var _a, _b, _c, _d;
+  field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lowerCamelCase(field.name);
+  field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lowerCamelCase(field.name);
+  field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO;
+  field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : field.repeat ? false : field.oneof ? false : field.kind == "message";
+  return field;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/oneof.js
+function isOneofGroup(any) {
+  if (typeof any != "object" || any === null || !any.hasOwnProperty("oneofKind")) {
+    return false;
+  }
+  switch (typeof any.oneofKind) {
+    case "string":
+      if (any[any.oneofKind] === void 0)
+        return false;
+      return Object.keys(any).length == 2;
+    case "undefined":
+      return Object.keys(any).length == 1;
+    default:
+      return false;
+  }
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-type-check.js
+var ReflectionTypeCheck = class {
+  constructor(info) {
+    var _a;
+    this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : [];
+  }
+  prepare() {
+    if (this.data)
+      return;
+    const req = [], known = [], oneofs = [];
+    for (let field of this.fields) {
+      if (field.oneof) {
+        if (!oneofs.includes(field.oneof)) {
+          oneofs.push(field.oneof);
+          req.push(field.oneof);
+          known.push(field.oneof);
+        }
+      } else {
+        known.push(field.localName);
+        switch (field.kind) {
+          case "scalar":
+          case "enum":
+            if (!field.opt || field.repeat)
+              req.push(field.localName);
+            break;
+          case "message":
+            if (field.repeat)
+              req.push(field.localName);
+            break;
+          case "map":
+            req.push(field.localName);
+            break;
+        }
+      }
+    }
+    this.data = { req, known, oneofs: Object.values(oneofs) };
+  }
+  /**
+   * 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(message, depth, allowExcessProperties = false) {
+    if (depth < 0)
+      return true;
+    if (message === null || message === void 0 || typeof message != "object")
+      return false;
+    this.prepare();
+    let keys = Object.keys(message), data = this.data;
+    if (keys.length < data.req.length || data.req.some((n) => !keys.includes(n)))
+      return false;
+    if (!allowExcessProperties) {
+      if (keys.some((k) => !data.known.includes(k)))
+        return false;
+    }
+    if (depth < 1) {
+      return true;
+    }
+    for (const name of data.oneofs) {
+      const group = message[name];
+      if (!isOneofGroup(group))
+        return false;
+      if (group.oneofKind === void 0)
+        continue;
+      const field = this.fields.find((f) => f.localName === group.oneofKind);
+      if (!field)
+        return false;
+      if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth))
+        return false;
+    }
+    for (const field of this.fields) {
+      if (field.oneof !== void 0)
+        continue;
+      if (!this.field(message[field.localName], field, allowExcessProperties, depth))
+        return false;
+    }
+    return true;
+  }
+  field(arg, field, allowExcessProperties, depth) {
+    let repeated = field.repeat;
+    switch (field.kind) {
+      case "scalar":
+        if (arg === void 0)
+          return field.opt;
+        if (repeated)
+          return this.scalars(arg, field.T, depth, field.L);
+        return this.scalar(arg, field.T, field.L);
+      case "enum":
+        if (arg === void 0)
+          return field.opt;
+        if (repeated)
+          return this.scalars(arg, ScalarType.INT32, depth);
+        return this.scalar(arg, ScalarType.INT32);
+      case "message":
+        if (arg === void 0)
+          return true;
+        if (repeated)
+          return this.messages(arg, field.T(), allowExcessProperties, depth);
+        return this.message(arg, field.T(), allowExcessProperties, depth);
+      case "map":
+        if (typeof arg != "object" || arg === null)
+          return false;
+        if (depth < 2)
+          return true;
+        if (!this.mapKeys(arg, field.K, depth))
+          return false;
+        switch (field.V.kind) {
+          case "scalar":
+            return this.scalars(Object.values(arg), field.V.T, depth, field.V.L);
+          case "enum":
+            return this.scalars(Object.values(arg), ScalarType.INT32, depth);
+          case "message":
+            return this.messages(Object.values(arg), field.V.T(), allowExcessProperties, depth);
+        }
+        break;
+    }
+    return true;
+  }
+  message(arg, type, allowExcessProperties, depth) {
+    if (allowExcessProperties) {
+      return type.isAssignable(arg, depth);
+    }
+    return type.is(arg, depth);
+  }
+  messages(arg, type, allowExcessProperties, depth) {
+    if (!Array.isArray(arg))
+      return false;
+    if (depth < 2)
+      return true;
+    if (allowExcessProperties) {
+      for (let i = 0; i < arg.length && i < depth; i++)
+        if (!type.isAssignable(arg[i], depth - 1))
+          return false;
+    } else {
+      for (let i = 0; i < arg.length && i < depth; i++)
+        if (!type.is(arg[i], depth - 1))
+          return false;
+    }
+    return true;
+  }
+  scalar(arg, type, longType) {
+    let argType = typeof arg;
+    switch (type) {
+      case ScalarType.UINT64:
+      case ScalarType.FIXED64:
+      case ScalarType.INT64:
+      case ScalarType.SFIXED64:
+      case ScalarType.SINT64:
+        switch (longType) {
+          case LongType.BIGINT:
+            return argType == "bigint";
+          case LongType.NUMBER:
+            return argType == "number" && !isNaN(arg);
+          default:
+            return argType == "string";
+        }
+      case ScalarType.BOOL:
+        return argType == "boolean";
+      case ScalarType.STRING:
+        return argType == "string";
+      case ScalarType.BYTES:
+        return arg instanceof Uint8Array;
+      case ScalarType.DOUBLE:
+      case ScalarType.FLOAT:
+        return argType == "number" && !isNaN(arg);
+      default:
+        return argType == "number" && Number.isInteger(arg);
+    }
+  }
+  scalars(arg, type, depth, longType) {
+    if (!Array.isArray(arg))
+      return false;
+    if (depth < 2)
+      return true;
+    if (Array.isArray(arg)) {
+      for (let i = 0; i < arg.length && i < depth; i++)
+        if (!this.scalar(arg[i], type, longType))
+          return false;
+    }
+    return true;
+  }
+  mapKeys(map, type, depth) {
+    let keys = Object.keys(map);
+    switch (type) {
+      case ScalarType.INT32:
+      case ScalarType.FIXED32:
+      case ScalarType.SFIXED32:
+      case ScalarType.SINT32:
+      case ScalarType.UINT32:
+        return this.scalars(keys.slice(0, depth).map((k) => parseInt(k)), type, depth);
+      case ScalarType.BOOL:
+        return this.scalars(keys.slice(0, depth).map((k) => k == "true" ? true : k == "false" ? false : k), type, depth);
+      default:
+        return this.scalars(keys, type, depth, LongType.STRING);
+    }
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-long-convert.js
+function reflectionLongConvert(long, type) {
+  switch (type) {
+    case LongType.BIGINT:
+      return long.toBigInt();
+    case LongType.NUMBER:
+      return long.toNumber();
+    default:
+      return long.toString();
+  }
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-reader.js
+var ReflectionJsonReader = class {
+  constructor(info) {
+    this.info = info;
+  }
+  prepare() {
+    var _a;
+    if (this.fMap === void 0) {
+      this.fMap = {};
+      const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
+      for (const field of fieldsInput) {
+        this.fMap[field.name] = field;
+        this.fMap[field.jsonName] = field;
+        this.fMap[field.localName] = field;
+      }
+    }
+  }
+  // Cannot parse JSON <type of jsonValue> for <type name>#<fieldName>.
+  assert(condition, fieldName, jsonValue) {
+    if (!condition) {
+      let what = typeofJsonValue(jsonValue);
+      if (what == "number" || what == "boolean")
+        what = jsonValue.toString();
+      throw new Error(`Cannot parse JSON ${what} for ${this.info.typeName}#${fieldName}`);
+    }
+  }
+  /**
+   * 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(input, message, options) {
+    this.prepare();
+    const oneofsHandled = [];
+    for (const [jsonKey, jsonValue] of Object.entries(input)) {
+      const field = this.fMap[jsonKey];
+      if (!field) {
+        if (!options.ignoreUnknownFields)
+          throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${jsonKey}`);
+        continue;
+      }
+      const localName = field.localName;
+      let target;
+      if (field.oneof) {
+        if (jsonValue === null && (field.kind !== "enum" || field.T()[0] !== "google.protobuf.NullValue")) {
+          continue;
+        }
+        if (oneofsHandled.includes(field.oneof))
+          throw new Error(`Multiple members of the oneof group "${field.oneof}" of ${this.info.typeName} are present in JSON.`);
+        oneofsHandled.push(field.oneof);
+        target = message[field.oneof] = {
+          oneofKind: localName
+        };
+      } else {
+        target = message;
+      }
+      if (field.kind == "map") {
+        if (jsonValue === null) {
+          continue;
+        }
+        this.assert(isJsonObject(jsonValue), field.name, jsonValue);
+        const fieldObj = target[localName];
+        for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) {
+          this.assert(jsonObjValue !== null, field.name + " map value", null);
+          let val;
+          switch (field.V.kind) {
+            case "message":
+              val = field.V.T().internalJsonRead(jsonObjValue, options);
+              break;
+            case "enum":
+              val = this.enum(field.V.T(), jsonObjValue, field.name, options.ignoreUnknownFields);
+              if (val === false)
+                continue;
+              break;
+            case "scalar":
+              val = this.scalar(jsonObjValue, field.V.T, field.V.L, field.name);
+              break;
+          }
+          this.assert(val !== void 0, field.name + " map value", jsonObjValue);
+          let key = jsonObjKey;
+          if (field.K == ScalarType.BOOL)
+            key = key == "true" ? true : key == "false" ? false : key;
+          key = this.scalar(key, field.K, LongType.STRING, field.name).toString();
+          fieldObj[key] = val;
+        }
+      } else if (field.repeat) {
+        if (jsonValue === null)
+          continue;
+        this.assert(Array.isArray(jsonValue), field.name, jsonValue);
+        const fieldArr = target[localName];
+        for (const jsonItem of jsonValue) {
+          this.assert(jsonItem !== null, field.name, null);
+          let val;
+          switch (field.kind) {
+            case "message":
+              val = field.T().internalJsonRead(jsonItem, options);
+              break;
+            case "enum":
+              val = this.enum(field.T(), jsonItem, field.name, options.ignoreUnknownFields);
+              if (val === false)
+                continue;
+              break;
+            case "scalar":
+              val = this.scalar(jsonItem, field.T, field.L, field.name);
+              break;
+          }
+          this.assert(val !== void 0, field.name, jsonValue);
+          fieldArr.push(val);
+        }
+      } else {
+        switch (field.kind) {
+          case "message":
+            if (jsonValue === null && field.T().typeName != "google.protobuf.Value") {
+              this.assert(field.oneof === void 0, field.name + " (oneof member)", null);
+              continue;
+            }
+            target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]);
+            break;
+          case "enum":
+            if (jsonValue === null)
+              continue;
+            let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields);
+            if (val === false)
+              continue;
+            target[localName] = val;
+            break;
+          case "scalar":
+            if (jsonValue === null)
+              continue;
+            target[localName] = this.scalar(jsonValue, field.T, field.L, field.name);
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * Returns `false` for unrecognized string representations.
+   *
+   * google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`).
+   */
+  enum(type, json, fieldName, ignoreUnknownFields) {
+    if (type[0] == "google.protobuf.NullValue")
+      assert(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`);
+    if (json === null)
+      return 0;
+    switch (typeof json) {
+      case "number":
+        assert(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`);
+        return json;
+      case "string":
+        let localEnumName = json;
+        if (type[2] && json.substring(0, type[2].length) === type[2])
+          localEnumName = json.substring(type[2].length);
+        let enumNumber = type[1][localEnumName];
+        if (typeof enumNumber === "undefined" && ignoreUnknownFields) {
+          return false;
+        }
+        assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`);
+        return enumNumber;
+    }
+    assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`);
+  }
+  scalar(json, type, longType, fieldName) {
+    let e;
+    try {
+      switch (type) {
+        // 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 ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+          if (json === null)
+            return 0;
+          if (json === "NaN")
+            return Number.NaN;
+          if (json === "Infinity")
+            return Number.POSITIVE_INFINITY;
+          if (json === "-Infinity")
+            return Number.NEGATIVE_INFINITY;
+          if (json === "") {
+            e = "empty string";
+            break;
+          }
+          if (typeof json == "string" && json.trim().length !== json.length) {
+            e = "extra whitespace";
+            break;
+          }
+          if (typeof json != "string" && typeof json != "number") {
+            break;
+          }
+          let float = Number(json);
+          if (Number.isNaN(float)) {
+            e = "not a number";
+            break;
+          }
+          if (!Number.isFinite(float)) {
+            e = "too large or small";
+            break;
+          }
+          if (type == ScalarType.FLOAT)
+            assertFloat32(float);
+          return float;
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+        case ScalarType.UINT32:
+          if (json === null)
+            return 0;
+          let int32;
+          if (typeof json == "number")
+            int32 = json;
+          else if (json === "")
+            e = "empty string";
+          else if (typeof json == "string") {
+            if (json.trim().length !== json.length)
+              e = "extra whitespace";
+            else
+              int32 = Number(json);
+          }
+          if (int32 === void 0)
+            break;
+          if (type == ScalarType.UINT32)
+            assertUInt32(int32);
+          else
+            assertInt32(int32);
+          return int32;
+        // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+          if (json === null)
+            return reflectionLongConvert(PbLong.ZERO, longType);
+          if (typeof json != "number" && typeof json != "string")
+            break;
+          return reflectionLongConvert(PbLong.from(json), longType);
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
+          if (json === null)
+            return reflectionLongConvert(PbULong.ZERO, longType);
+          if (typeof json != "number" && typeof json != "string")
+            break;
+          return reflectionLongConvert(PbULong.from(json), longType);
+        // bool:
+        case ScalarType.BOOL:
+          if (json === null)
+            return false;
+          if (typeof json !== "boolean")
+            break;
+          return json;
+        // string:
+        case ScalarType.STRING:
+          if (json === null)
+            return "";
+          if (typeof json !== "string") {
+            e = "extra whitespace";
+            break;
+          }
+          try {
+            encodeURIComponent(json);
+          } catch (e2) {
+            e2 = "invalid UTF8";
+            break;
+          }
+          return json;
+        // 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 ScalarType.BYTES:
+          if (json === null || json === "")
+            return new Uint8Array(0);
+          if (typeof json !== "string")
+            break;
+          return base64decode(json);
+      }
+    } catch (error) {
+      e = error.message;
+    }
+    this.assert(false, fieldName + (e ? " - " + e : ""), json);
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-writer.js
+var ReflectionJsonWriter = class {
+  constructor(info) {
+    var _a;
+    this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : [];
+  }
+  /**
+   * Converts the message to a JSON object, based on the field descriptors.
+   */
+  write(message, options) {
+    const json = {}, source = message;
+    for (const field of this.fields) {
+      if (!field.oneof) {
+        let jsonValue2 = this.field(field, source[field.localName], options);
+        if (jsonValue2 !== void 0)
+          json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue2;
+        continue;
+      }
+      const group = source[field.oneof];
+      if (group.oneofKind !== field.localName)
+        continue;
+      const opt = field.kind == "scalar" || field.kind == "enum" ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options;
+      let jsonValue = this.field(field, group[field.localName], opt);
+      assert(jsonValue !== void 0);
+      json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
+    }
+    return json;
+  }
+  field(field, value, options) {
+    let jsonValue = void 0;
+    if (field.kind == "map") {
+      assert(typeof value == "object" && value !== null);
+      const jsonObj = {};
+      switch (field.V.kind) {
+        case "scalar":
+          for (const [entryKey, entryValue] of Object.entries(value)) {
+            const val = this.scalar(field.V.T, entryValue, field.name, false, true);
+            assert(val !== void 0);
+            jsonObj[entryKey.toString()] = val;
+          }
+          break;
+        case "message":
+          const messageType = field.V.T();
+          for (const [entryKey, entryValue] of Object.entries(value)) {
+            const val = this.message(messageType, entryValue, field.name, options);
+            assert(val !== void 0);
+            jsonObj[entryKey.toString()] = val;
+          }
+          break;
+        case "enum":
+          const enumInfo = field.V.T();
+          for (const [entryKey, entryValue] of Object.entries(value)) {
+            assert(entryValue === void 0 || typeof entryValue == "number");
+            const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger);
+            assert(val !== void 0);
+            jsonObj[entryKey.toString()] = val;
+          }
+          break;
+      }
+      if (options.emitDefaultValues || Object.keys(jsonObj).length > 0)
+        jsonValue = jsonObj;
+    } else if (field.repeat) {
+      assert(Array.isArray(value));
+      const jsonArr = [];
+      switch (field.kind) {
+        case "scalar":
+          for (let i = 0; i < value.length; i++) {
+            const val = this.scalar(field.T, value[i], field.name, field.opt, true);
+            assert(val !== void 0);
+            jsonArr.push(val);
+          }
+          break;
+        case "enum":
+          const enumInfo = field.T();
+          for (let i = 0; i < value.length; i++) {
+            assert(value[i] === void 0 || typeof value[i] == "number");
+            const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger);
+            assert(val !== void 0);
+            jsonArr.push(val);
+          }
+          break;
+        case "message":
+          const messageType = field.T();
+          for (let i = 0; i < value.length; i++) {
+            const val = this.message(messageType, value[i], field.name, options);
+            assert(val !== void 0);
+            jsonArr.push(val);
+          }
+          break;
+      }
+      if (options.emitDefaultValues || jsonArr.length > 0 || options.emitDefaultValues)
+        jsonValue = jsonArr;
+    } else {
+      switch (field.kind) {
+        case "scalar":
+          jsonValue = this.scalar(field.T, value, field.name, field.opt, options.emitDefaultValues);
+          break;
+        case "enum":
+          jsonValue = this.enum(field.T(), value, field.name, field.opt, options.emitDefaultValues, options.enumAsInteger);
+          break;
+        case "message":
+          jsonValue = this.message(field.T(), value, field.name, options);
+          break;
+      }
+    }
+    return jsonValue;
+  }
+  /**
+   * Returns `null` as the default for google.protobuf.NullValue.
+   */
+  enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) {
+    if (type[0] == "google.protobuf.NullValue")
+      return !emitDefaultValues && !optional ? void 0 : null;
+    if (value === void 0) {
+      assert(optional);
+      return void 0;
+    }
+    if (value === 0 && !emitDefaultValues && !optional)
+      return void 0;
+    assert(typeof value == "number");
+    assert(Number.isInteger(value));
+    if (enumAsInteger || !type[1].hasOwnProperty(value))
+      return value;
+    if (type[2])
+      return type[2] + type[1][value];
+    return type[1][value];
+  }
+  message(type, value, fieldName, options) {
+    if (value === void 0)
+      return options.emitDefaultValues ? null : void 0;
+    return type.internalJsonWrite(value, options);
+  }
+  scalar(type, value, fieldName, optional, emitDefaultValues) {
+    if (value === void 0) {
+      assert(optional);
+      return void 0;
+    }
+    const ed = emitDefaultValues || optional;
+    switch (type) {
+      // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+      case ScalarType.INT32:
+      case ScalarType.SFIXED32:
+      case ScalarType.SINT32:
+        if (value === 0)
+          return ed ? 0 : void 0;
+        assertInt32(value);
+        return value;
+      case ScalarType.FIXED32:
+      case ScalarType.UINT32:
+        if (value === 0)
+          return ed ? 0 : void 0;
+        assertUInt32(value);
+        return value;
+      // 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 ScalarType.FLOAT:
+        assertFloat32(value);
+      case ScalarType.DOUBLE:
+        if (value === 0)
+          return ed ? 0 : void 0;
+        assert(typeof value == "number");
+        if (Number.isNaN(value))
+          return "NaN";
+        if (value === Number.POSITIVE_INFINITY)
+          return "Infinity";
+        if (value === Number.NEGATIVE_INFINITY)
+          return "-Infinity";
+        return value;
+      // string:
+      case ScalarType.STRING:
+        if (value === "")
+          return ed ? "" : void 0;
+        assert(typeof value == "string");
+        return value;
+      // bool:
+      case ScalarType.BOOL:
+        if (value === false)
+          return ed ? false : void 0;
+        assert(typeof value == "boolean");
+        return value;
+      // JSON value will be a decimal string. Either numbers or strings are accepted.
+      case ScalarType.UINT64:
+      case ScalarType.FIXED64:
+        assert(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
+        let ulong = PbULong.from(value);
+        if (ulong.isZero() && !ed)
+          return void 0;
+        return ulong.toString();
+      // JSON value will be a decimal string. Either numbers or strings are accepted.
+      case ScalarType.INT64:
+      case ScalarType.SFIXED64:
+      case ScalarType.SINT64:
+        assert(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
+        let long = PbLong.from(value);
+        if (long.isZero() && !ed)
+          return void 0;
+        return long.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 ScalarType.BYTES:
+        assert(value instanceof Uint8Array);
+        if (!value.byteLength)
+          return ed ? "" : void 0;
+        return base64encode(value);
+    }
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-scalar-default.js
+function reflectionScalarDefault(type, longType = LongType.STRING) {
+  switch (type) {
+    case ScalarType.BOOL:
+      return false;
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return reflectionLongConvert(PbULong.ZERO, longType);
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      return reflectionLongConvert(PbLong.ZERO, longType);
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      return 0;
+    case ScalarType.BYTES:
+      return new Uint8Array(0);
+    case ScalarType.STRING:
+      return "";
+    default:
+      return 0;
+  }
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-reader.js
+var ReflectionBinaryReader = class {
+  constructor(info) {
+    this.info = info;
+  }
+  prepare() {
+    var _a;
+    if (!this.fieldNoToField) {
+      const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
+      this.fieldNoToField = new Map(fieldsInput.map((field) => [field.no, field]));
+    }
+  }
+  /**
+   * 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(reader, message, options, length) {
+    this.prepare();
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag(), field = this.fieldNoToField.get(fieldNo);
+      if (!field) {
+        let u = options.readUnknownField;
+        if (u == "throw")
+          throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.info.typeName}`);
+        let d = reader.skip(wireType);
+        if (u !== false)
+          (u === true ? UnknownFieldHandler.onRead : u)(this.info.typeName, message, fieldNo, wireType, d);
+        continue;
+      }
+      let target = message, repeated = field.repeat, localName = field.localName;
+      if (field.oneof) {
+        target = target[field.oneof];
+        if (target.oneofKind !== localName)
+          target = message[field.oneof] = {
+            oneofKind: localName
+          };
+      }
+      switch (field.kind) {
+        case "scalar":
+        case "enum":
+          let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
+          let L = field.kind == "scalar" ? field.L : void 0;
+          if (repeated) {
+            let arr = target[localName];
+            if (wireType == WireType.LengthDelimited && T != ScalarType.STRING && T != ScalarType.BYTES) {
+              let e = reader.uint32() + reader.pos;
+              while (reader.pos < e)
+                arr.push(this.scalar(reader, T, L));
+            } else
+              arr.push(this.scalar(reader, T, L));
+          } else
+            target[localName] = this.scalar(reader, T, L);
+          break;
+        case "message":
+          if (repeated) {
+            let arr = target[localName];
+            let msg = field.T().internalBinaryRead(reader, reader.uint32(), options);
+            arr.push(msg);
+          } else
+            target[localName] = field.T().internalBinaryRead(reader, reader.uint32(), options, target[localName]);
+          break;
+        case "map":
+          let [mapKey, mapVal] = this.mapEntry(field, reader, options);
+          target[localName][mapKey] = mapVal;
+          break;
+      }
+    }
+  }
+  /**
+   * Read a map field, expecting key field = 1, value field = 2
+   */
+  mapEntry(field, reader, options) {
+    let length = reader.uint32();
+    let end = reader.pos + length;
+    let key = void 0;
+    let val = void 0;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          if (field.K == ScalarType.BOOL)
+            key = reader.bool().toString();
+          else
+            key = this.scalar(reader, field.K, LongType.STRING);
+          break;
+        case 2:
+          switch (field.V.kind) {
+            case "scalar":
+              val = this.scalar(reader, field.V.T, field.V.L);
+              break;
+            case "enum":
+              val = reader.int32();
+              break;
+            case "message":
+              val = field.V.T().internalBinaryRead(reader, reader.uint32(), options);
+              break;
+          }
+          break;
+        default:
+          throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) in map entry for ${this.info.typeName}#${field.name}`);
+      }
+    }
+    if (key === void 0) {
+      let keyRaw = reflectionScalarDefault(field.K);
+      key = field.K == ScalarType.BOOL ? keyRaw.toString() : keyRaw;
+    }
+    if (val === void 0)
+      switch (field.V.kind) {
+        case "scalar":
+          val = reflectionScalarDefault(field.V.T, field.V.L);
+          break;
+        case "enum":
+          val = 0;
+          break;
+        case "message":
+          val = field.V.T().create();
+          break;
+      }
+    return [key, val];
+  }
+  scalar(reader, type, longType) {
+    switch (type) {
+      case ScalarType.INT32:
+        return reader.int32();
+      case ScalarType.STRING:
+        return reader.string();
+      case ScalarType.BOOL:
+        return reader.bool();
+      case ScalarType.DOUBLE:
+        return reader.double();
+      case ScalarType.FLOAT:
+        return reader.float();
+      case ScalarType.INT64:
+        return reflectionLongConvert(reader.int64(), longType);
+      case ScalarType.UINT64:
+        return reflectionLongConvert(reader.uint64(), longType);
+      case ScalarType.FIXED64:
+        return reflectionLongConvert(reader.fixed64(), longType);
+      case ScalarType.FIXED32:
+        return reader.fixed32();
+      case ScalarType.BYTES:
+        return reader.bytes();
+      case ScalarType.UINT32:
+        return reader.uint32();
+      case ScalarType.SFIXED32:
+        return reader.sfixed32();
+      case ScalarType.SFIXED64:
+        return reflectionLongConvert(reader.sfixed64(), longType);
+      case ScalarType.SINT32:
+        return reader.sint32();
+      case ScalarType.SINT64:
+        return reflectionLongConvert(reader.sint64(), longType);
+    }
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-writer.js
+var ReflectionBinaryWriter = class {
+  constructor(info) {
+    this.info = info;
+  }
+  prepare() {
+    if (!this.fields) {
+      const fieldsInput = this.info.fields ? this.info.fields.concat() : [];
+      this.fields = fieldsInput.sort((a, b) => a.no - b.no);
+    }
+  }
+  /**
+   * Writes the message to binary format.
+   */
+  write(message, writer, options) {
+    this.prepare();
+    for (const field of this.fields) {
+      let value, emitDefault, repeated = field.repeat, localName = field.localName;
+      if (field.oneof) {
+        const group = message[field.oneof];
+        if (group.oneofKind !== localName)
+          continue;
+        value = group[localName];
+        emitDefault = true;
+      } else {
+        value = message[localName];
+        emitDefault = false;
+      }
+      switch (field.kind) {
+        case "scalar":
+        case "enum":
+          let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
+          if (repeated) {
+            assert(Array.isArray(value));
+            if (repeated == RepeatType.PACKED)
+              this.packed(writer, T, field.no, value);
+            else
+              for (const item of value)
+                this.scalar(writer, T, field.no, item, true);
+          } else if (value === void 0)
+            assert(field.opt);
+          else
+            this.scalar(writer, T, field.no, value, emitDefault || field.opt);
+          break;
+        case "message":
+          if (repeated) {
+            assert(Array.isArray(value));
+            for (const item of value)
+              this.message(writer, options, field.T(), field.no, item);
+          } else {
+            this.message(writer, options, field.T(), field.no, value);
+          }
+          break;
+        case "map":
+          assert(typeof value == "object" && value !== null);
+          for (const [key, val] of Object.entries(value))
+            this.mapEntry(writer, options, field, key, val);
+          break;
+      }
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u === true ? UnknownFieldHandler.onWrite : u)(this.info.typeName, message, writer);
+  }
+  mapEntry(writer, options, field, key, value) {
+    writer.tag(field.no, WireType.LengthDelimited);
+    writer.fork();
+    let keyValue = key;
+    switch (field.K) {
+      case ScalarType.INT32:
+      case ScalarType.FIXED32:
+      case ScalarType.UINT32:
+      case ScalarType.SFIXED32:
+      case ScalarType.SINT32:
+        keyValue = Number.parseInt(key);
+        break;
+      case ScalarType.BOOL:
+        assert(key == "true" || key == "false");
+        keyValue = key == "true";
+        break;
+    }
+    this.scalar(writer, field.K, 1, keyValue, true);
+    switch (field.V.kind) {
+      case "scalar":
+        this.scalar(writer, field.V.T, 2, value, true);
+        break;
+      case "enum":
+        this.scalar(writer, ScalarType.INT32, 2, value, true);
+        break;
+      case "message":
+        this.message(writer, options, field.V.T(), 2, value);
+        break;
+    }
+    writer.join();
+  }
+  message(writer, options, handler, fieldNo, value) {
+    if (value === void 0)
+      return;
+    handler.internalBinaryWrite(value, writer.tag(fieldNo, WireType.LengthDelimited).fork(), options);
+    writer.join();
+  }
+  /**
+   * Write a single scalar value.
+   */
+  scalar(writer, type, fieldNo, value, emitDefault) {
+    let [wireType, method, isDefault] = this.scalarInfo(type, value);
+    if (!isDefault || emitDefault) {
+      writer.tag(fieldNo, wireType);
+      writer[method](value);
+    }
+  }
+  /**
+   * Write an array of scalar values in packed format.
+   */
+  packed(writer, type, fieldNo, value) {
+    if (!value.length)
+      return;
+    assert(type !== ScalarType.BYTES && type !== ScalarType.STRING);
+    writer.tag(fieldNo, WireType.LengthDelimited);
+    writer.fork();
+    let [, method] = this.scalarInfo(type);
+    for (let i = 0; i < value.length; i++)
+      writer[method](value[i]);
+    writer.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(type, value) {
+    let t = WireType.Varint;
+    let m;
+    let i = value === void 0;
+    let d = value === 0;
+    switch (type) {
+      case ScalarType.INT32:
+        m = "int32";
+        break;
+      case ScalarType.STRING:
+        d = i || !value.length;
+        t = WireType.LengthDelimited;
+        m = "string";
+        break;
+      case ScalarType.BOOL:
+        d = value === false;
+        m = "bool";
+        break;
+      case ScalarType.UINT32:
+        m = "uint32";
+        break;
+      case ScalarType.DOUBLE:
+        t = WireType.Bit64;
+        m = "double";
+        break;
+      case ScalarType.FLOAT:
+        t = WireType.Bit32;
+        m = "float";
+        break;
+      case ScalarType.INT64:
+        d = i || PbLong.from(value).isZero();
+        m = "int64";
+        break;
+      case ScalarType.UINT64:
+        d = i || PbULong.from(value).isZero();
+        m = "uint64";
+        break;
+      case ScalarType.FIXED64:
+        d = i || PbULong.from(value).isZero();
+        t = WireType.Bit64;
+        m = "fixed64";
+        break;
+      case ScalarType.BYTES:
+        d = i || !value.byteLength;
+        t = WireType.LengthDelimited;
+        m = "bytes";
+        break;
+      case ScalarType.FIXED32:
+        t = WireType.Bit32;
+        m = "fixed32";
+        break;
+      case ScalarType.SFIXED32:
+        t = WireType.Bit32;
+        m = "sfixed32";
+        break;
+      case ScalarType.SFIXED64:
+        d = i || PbLong.from(value).isZero();
+        t = WireType.Bit64;
+        m = "sfixed64";
+        break;
+      case ScalarType.SINT32:
+        m = "sint32";
+        break;
+      case ScalarType.SINT64:
+        d = i || PbLong.from(value).isZero();
+        m = "sint64";
+        break;
+    }
+    return [t, m, i || d];
+  }
+};
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-create.js
+function reflectionCreate(type) {
+  const msg = type.messagePrototype ? Object.create(type.messagePrototype) : Object.defineProperty({}, MESSAGE_TYPE, { value: type });
+  for (let field of type.fields) {
+    let name = field.localName;
+    if (field.opt)
+      continue;
+    if (field.oneof)
+      msg[field.oneof] = { oneofKind: void 0 };
+    else if (field.repeat)
+      msg[name] = [];
+    else
+      switch (field.kind) {
+        case "scalar":
+          msg[name] = reflectionScalarDefault(field.T, field.L);
+          break;
+        case "enum":
+          msg[name] = 0;
+          break;
+        case "map":
+          msg[name] = {};
+          break;
+      }
+  }
+  return msg;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-merge-partial.js
+function reflectionMergePartial(info, target, source) {
+  let fieldValue, input = source, output;
+  for (let field of info.fields) {
+    let name = field.localName;
+    if (field.oneof) {
+      const group = input[field.oneof];
+      if ((group === null || group === void 0 ? void 0 : group.oneofKind) == void 0) {
+        continue;
+      }
+      fieldValue = group[name];
+      output = target[field.oneof];
+      output.oneofKind = group.oneofKind;
+      if (fieldValue == void 0) {
+        delete output[name];
+        continue;
+      }
+    } else {
+      fieldValue = input[name];
+      output = target;
+      if (fieldValue == void 0) {
+        continue;
+      }
+    }
+    if (field.repeat)
+      output[name].length = fieldValue.length;
+    switch (field.kind) {
+      case "scalar":
+      case "enum":
+        if (field.repeat)
+          for (let i = 0; i < fieldValue.length; i++)
+            output[name][i] = fieldValue[i];
+        else
+          output[name] = fieldValue;
+        break;
+      case "message":
+        let T = field.T();
+        if (field.repeat)
+          for (let i = 0; i < fieldValue.length; i++)
+            output[name][i] = T.create(fieldValue[i]);
+        else if (output[name] === void 0)
+          output[name] = T.create(fieldValue);
+        else
+          T.mergePartial(output[name], fieldValue);
+        break;
+      case "map":
+        switch (field.V.kind) {
+          case "scalar":
+          case "enum":
+            Object.assign(output[name], fieldValue);
+            break;
+          case "message":
+            let T2 = field.V.T();
+            for (let k of Object.keys(fieldValue))
+              output[name][k] = T2.create(fieldValue[k]);
+            break;
+        }
+        break;
+    }
+  }
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/reflection-equals.js
+function reflectionEquals(info, a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return false;
+  for (let field of info.fields) {
+    let localName = field.localName;
+    let val_a = field.oneof ? a[field.oneof][localName] : a[localName];
+    let val_b = field.oneof ? b[field.oneof][localName] : b[localName];
+    switch (field.kind) {
+      case "enum":
+      case "scalar":
+        let t = field.kind == "enum" ? ScalarType.INT32 : field.T;
+        if (!(field.repeat ? repeatedPrimitiveEq(t, val_a, val_b) : primitiveEq(t, val_a, val_b)))
+          return false;
+        break;
+      case "map":
+        if (!(field.V.kind == "message" ? repeatedMsgEq(field.V.T(), objectValues(val_a), objectValues(val_b)) : repeatedPrimitiveEq(field.V.kind == "enum" ? ScalarType.INT32 : field.V.T, objectValues(val_a), objectValues(val_b))))
+          return false;
+        break;
+      case "message":
+        let T = field.T();
+        if (!(field.repeat ? repeatedMsgEq(T, val_a, val_b) : T.equals(val_a, val_b)))
+          return false;
+        break;
+    }
+  }
+  return true;
+}
+var objectValues = Object.values;
+function primitiveEq(type, a, b) {
+  if (a === b)
+    return true;
+  if (type !== ScalarType.BYTES)
+    return false;
+  let ba = a;
+  let bb = b;
+  if (ba.length !== bb.length)
+    return false;
+  for (let i = 0; i < ba.length; i++)
+    if (ba[i] != bb[i])
+      return false;
+  return true;
+}
+function repeatedPrimitiveEq(type, a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++)
+    if (!primitiveEq(type, a[i], b[i]))
+      return false;
+  return true;
+}
+function repeatedMsgEq(type, a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++)
+    if (!type.equals(a[i], b[i]))
+      return false;
+  return true;
+}
+
+// node_modules/@protobuf-ts/runtime/build/es2015/message-type.js
+var baseDescriptors = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({}));
+var MessageType = class {
+  constructor(name, fields, options) {
+    this.defaultCheckDepth = 16;
+    this.typeName = name;
+    this.fields = fields.map(normalizeFieldInfo);
+    this.options = options !== null && options !== void 0 ? options : {};
+    this.messagePrototype = Object.create(null, Object.assign(Object.assign({}, baseDescriptors), { [MESSAGE_TYPE]: { value: this } }));
+    this.refTypeCheck = new ReflectionTypeCheck(this);
+    this.refJsonReader = new ReflectionJsonReader(this);
+    this.refJsonWriter = new ReflectionJsonWriter(this);
+    this.refBinReader = new ReflectionBinaryReader(this);
+    this.refBinWriter = new ReflectionBinaryWriter(this);
+  }
+  create(value) {
+    let message = reflectionCreate(this);
+    if (value !== void 0) {
+      reflectionMergePartial(this, message, value);
+    }
+    return message;
+  }
+  /**
+   * Clone the message.
+   *
+   * Unknown fields are discarded.
+   */
+  clone(message) {
+    let copy = this.create();
+    reflectionMergePartial(this, copy, message);
+    return copy;
+  }
+  /**
+   * 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(a, b) {
+    return reflectionEquals(this, a, b);
+  }
+  /**
+   * 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(arg, depth = this.defaultCheckDepth) {
+    return this.refTypeCheck.is(arg, depth, false);
+  }
+  /**
+   * 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(arg, depth = this.defaultCheckDepth) {
+    return this.refTypeCheck.is(arg, depth, true);
+  }
+  /**
+   * Copy partial data into the target message.
+   */
+  mergePartial(target, source) {
+    reflectionMergePartial(this, target, source);
+  }
+  /**
+   * Create a new message from binary format.
+   */
+  fromBinary(data, options) {
+    let opt = binaryReadOptions(options);
+    return this.internalBinaryRead(opt.readerFactory(data), data.byteLength, opt);
+  }
+  /**
+   * Read a new message from a JSON value.
+   */
+  fromJson(json, options) {
+    return this.internalJsonRead(json, jsonReadOptions(options));
+  }
+  /**
+   * Read a new message from a JSON string.
+   * This is equivalent to `T.fromJson(JSON.parse(json))`.
+   */
+  fromJsonString(json, options) {
+    let value = JSON.parse(json);
+    return this.fromJson(value, options);
+  }
+  /**
+   * Write the message to canonical JSON value.
+   */
+  toJson(message, options) {
+    return this.internalJsonWrite(message, jsonWriteOptions(options));
+  }
+  /**
+   * Convert the message to canonical JSON string.
+   * This is equivalent to `JSON.stringify(T.toJson(t))`
+   */
+  toJsonString(message, options) {
+    var _a;
+    let value = this.toJson(message, options);
+    return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
+  }
+  /**
+   * Write the message to binary format.
+   */
+  toBinary(message, options) {
+    let opt = binaryWriteOptions(options);
+    return this.internalBinaryWrite(message, opt.writerFactory(), opt).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(json, options, target) {
+    if (json !== null && typeof json == "object" && !Array.isArray(json)) {
+      let message = target !== null && target !== void 0 ? target : this.create();
+      this.refJsonReader.read(json, message, options);
+      return message;
+    }
+    throw new Error(`Unable to parse message ${this.typeName} from JSON ${typeofJsonValue(json)}.`);
+  }
+  /**
+   * 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(message, options) {
+    return this.refJsonWriter.write(message, options);
+  }
+  /**
+   * 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(message, writer, options) {
+    this.refBinWriter.write(message, writer, options);
+    return writer;
+  }
+  /**
+   * 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(reader, length, options, target) {
+    let message = target !== null && target !== void 0 ? target : this.create();
+    this.refBinReader.read(reader, message, options, length);
+    return message;
+  }
+};
+
+// src/internal/az/azreq/grpc/v1/generated/google/protobuf/struct.ts
+var NullValue = /* @__PURE__ */ ((NullValue2) => {
+  NullValue2[NullValue2["NULL_VALUE"] = 0] = "NULL_VALUE";
+  return NullValue2;
+})(NullValue || {});
+var Struct$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.Struct", [
+      { no: 1, name: "fields", kind: "map", K: 9, V: { kind: "message", T: () => Value } }
+    ]);
+  }
+  /**
+   * Encode `Struct` to JSON object.
+   */
+  internalJsonWrite(message, options) {
+    let json = {};
+    for (let [k, v] of Object.entries(message.fields)) {
+      json[k] = Value.toJson(v);
+    }
+    return json;
+  }
+  /**
+   * Decode `Struct` from JSON object.
+   */
+  internalJsonRead(json, options, target) {
+    if (!isJsonObject(json))
+      throw new globalThis.Error("Unable to parse message " + this.typeName + " from JSON " + typeofJsonValue(json) + ".");
+    if (!target)
+      target = this.create();
+    for (let [k, v] of globalThis.Object.entries(json)) {
+      target.fields[k] = Value.fromJson(v);
+    }
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.fields = {};
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* map<string, google.protobuf.Value> fields */
+        1:
+          this.binaryReadMap1(message.fields, reader, options);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  binaryReadMap1(map, reader, options) {
+    let len = reader.uint32(), end = reader.pos + len, key, val;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          key = reader.string();
+          break;
+        case 2:
+          val = Value.internalBinaryRead(reader, reader.uint32(), options);
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for field google.protobuf.Struct.fields");
+      }
+    }
+    map[key != null ? key : ""] = val != null ? val : Value.create();
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let k of globalThis.Object.keys(message.fields)) {
+      writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+      writer.tag(2, WireType.LengthDelimited).fork();
+      Value.internalBinaryWrite(message.fields[k], writer, options);
+      writer.join().join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Struct = new Struct$Type();
+var Value$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.Value", [
+      { no: 1, name: "null_value", kind: "enum", oneof: "kind", T: () => ["google.protobuf.NullValue", NullValue] },
+      {
+        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: () => Struct },
+      { no: 6, name: "list_value", kind: "message", oneof: "kind", T: () => ListValue }
+    ]);
+  }
+  /**
+   * Encode `Value` to JSON value.
+   */
+  internalJsonWrite(message, options) {
+    if (message.kind.oneofKind === void 0)
+      throw new globalThis.Error();
+    switch (message.kind.oneofKind) {
+      case void 0:
+        throw new globalThis.Error();
+      case "boolValue":
+        return message.kind.boolValue;
+      case "nullValue":
+        return null;
+      case "numberValue":
+        let numberValue = message.kind.numberValue;
+        if (typeof numberValue == "number" && !Number.isFinite(numberValue))
+          throw new globalThis.Error();
+        return numberValue;
+      case "stringValue":
+        return message.kind.stringValue;
+      case "listValue":
+        let listValueField = this.fields.find((f) => f.no === 6);
+        if ((listValueField == null ? void 0 : listValueField.kind) !== "message")
+          throw new globalThis.Error();
+        return listValueField.T().toJson(message.kind.listValue);
+      case "structValue":
+        let structValueField = this.fields.find((f) => f.no === 5);
+        if ((structValueField == null ? void 0 : structValueField.kind) !== "message")
+          throw new globalThis.Error();
+        return structValueField.T().toJson(message.kind.structValue);
+    }
+  }
+  /**
+   * Decode `Value` from JSON value.
+   */
+  internalJsonRead(json, options, target) {
+    if (!target)
+      target = this.create();
+    switch (typeof json) {
+      case "number":
+        target.kind = { oneofKind: "numberValue", numberValue: json };
+        break;
+      case "string":
+        target.kind = { oneofKind: "stringValue", stringValue: json };
+        break;
+      case "boolean":
+        target.kind = { oneofKind: "boolValue", boolValue: json };
+        break;
+      case "object":
+        if (json === null) {
+          target.kind = { oneofKind: "nullValue", nullValue: 0 /* NULL_VALUE */ };
+        } else if (globalThis.Array.isArray(json)) {
+          target.kind = { oneofKind: "listValue", listValue: ListValue.fromJson(json) };
+        } else {
+          target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
+        }
+        break;
+      default:
+        throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+    }
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* google.protobuf.NullValue null_value */
+        1:
+          message.kind = {
+            oneofKind: "nullValue",
+            nullValue: reader.int32()
+          };
+          break;
+        case /* double number_value */
+        2:
+          message.kind = {
+            oneofKind: "numberValue",
+            numberValue: reader.double()
+          };
+          break;
+        case /* string string_value */
+        3:
+          message.kind = {
+            oneofKind: "stringValue",
+            stringValue: reader.string()
+          };
+          break;
+        case /* bool bool_value */
+        4:
+          message.kind = {
+            oneofKind: "boolValue",
+            boolValue: reader.bool()
+          };
+          break;
+        case /* google.protobuf.Struct struct_value */
+        5:
+          message.kind = {
+            oneofKind: "structValue",
+            structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.kind.structValue)
+          };
+          break;
+        case /* google.protobuf.ListValue list_value */
+        6:
+          message.kind = {
+            oneofKind: "listValue",
+            listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, message.kind.listValue)
+          };
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.kind.oneofKind === "nullValue")
+      writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
+    if (message.kind.oneofKind === "numberValue")
+      writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
+    if (message.kind.oneofKind === "stringValue")
+      writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
+    if (message.kind.oneofKind === "boolValue")
+      writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
+    if (message.kind.oneofKind === "structValue")
+      Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    if (message.kind.oneofKind === "listValue")
+      ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Value = new Value$Type();
+var ListValue$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.ListValue", [
+      { no: 1, name: "values", kind: "message", repeat: 1, T: () => Value }
+    ]);
+  }
+  /**
+   * Encode `ListValue` to JSON array.
+   */
+  internalJsonWrite(message, options) {
+    return message.values.map((v) => Value.toJson(v));
+  }
+  /**
+   * Decode `ListValue` from JSON array.
+   */
+  internalJsonRead(json, options, target) {
+    if (!globalThis.Array.isArray(json))
+      throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+    if (!target)
+      target = this.create();
+    let values = json.map((v) => Value.fromJson(v));
+    target.values.push(...values);
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.values = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.Value values */
+        1:
+          message.values.push(Value.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.values.length; i++)
+      Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ListValue = new ListValue$Type();
+
+// src/internal/az/azreq/grpc/v1/generated/proto/v1/pdp.ts
+var PolicyStore$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.PolicyStore", [
+      {
+        no: 1,
+        name: "Kind",
+        kind: "scalar",
+        jsonName: "Kind",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "ID",
+        kind: "scalar",
+        jsonName: "ID",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = "";
+    message.iD = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Kind = 1 [json_name = "Kind"];*/
+        1:
+          message.kind = reader.string();
+          break;
+        case /* string ID = 2 [json_name = "ID"];*/
+        2:
+          message.iD = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.kind !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.kind);
+    if (message.iD !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.iD);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var PolicyStore = new PolicyStore$Type();
+var Principal$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.Principal", [
+      {
+        no: 1,
+        name: "Type",
+        kind: "scalar",
+        jsonName: "Type",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "ID",
+        kind: "scalar",
+        jsonName: "ID",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "Source",
+        kind: "scalar",
+        jsonName: "Source",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "IdentityToken",
+        kind: "scalar",
+        jsonName: "IdentityToken",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "AccessToken",
+        kind: "scalar",
+        jsonName: "AccessToken",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = "";
+    message.iD = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Type = 1 [json_name = "Type"];*/
+        1:
+          message.type = reader.string();
+          break;
+        case /* string ID = 2 [json_name = "ID"];*/
+        2:
+          message.iD = reader.string();
+          break;
+        case /* optional string Source = 3 [json_name = "Source"];*/
+        3:
+          message.source = reader.string();
+          break;
+        case /* optional string IdentityToken = 4 [json_name = "IdentityToken"];*/
+        4:
+          message.identityToken = reader.string();
+          break;
+        case /* optional string AccessToken = 5 [json_name = "AccessToken"];*/
+        5:
+          message.accessToken = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.type);
+    if (message.iD !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.iD);
+    if (message.source !== void 0)
+      writer.tag(3, WireType.LengthDelimited).string(message.source);
+    if (message.identityToken !== void 0)
+      writer.tag(4, WireType.LengthDelimited).string(message.identityToken);
+    if (message.accessToken !== void 0)
+      writer.tag(5, WireType.LengthDelimited).string(message.accessToken);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Principal = new Principal$Type();
+var Entities$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.Entities", [
+      {
+        no: 1,
+        name: "Schema",
+        kind: "scalar",
+        jsonName: "Schema",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "Items", kind: "message", jsonName: "Items", repeat: 1, T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.schema = "";
+    message.items = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Schema = 1 [json_name = "Schema"];*/
+        1:
+          message.schema = reader.string();
+          break;
+        case /* repeated google.protobuf.Struct Items = 2 [json_name = "Items"];*/
+        2:
+          message.items.push(Struct.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.schema !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.schema);
+    for (let i = 0; i < message.items.length; i++)
+      Struct.internalBinaryWrite(message.items[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Entities = new Entities$Type();
+var Subject$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.Subject", [
+      {
+        no: 1,
+        name: "Type",
+        kind: "scalar",
+        jsonName: "Type",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "ID",
+        kind: "scalar",
+        jsonName: "ID",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "Source",
+        kind: "scalar",
+        jsonName: "Source",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "Properties", kind: "message", jsonName: "Properties", T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = "";
+    message.iD = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Type = 1 [json_name = "Type"];*/
+        1:
+          message.type = reader.string();
+          break;
+        case /* string ID = 2 [json_name = "ID"];*/
+        2:
+          message.iD = reader.string();
+          break;
+        case /* optional string Source = 3 [json_name = "Source"];*/
+        3:
+          message.source = reader.string();
+          break;
+        case /* optional google.protobuf.Struct Properties = 4 [json_name = "Properties"];*/
+        4:
+          message.properties = Struct.internalBinaryRead(reader, reader.uint32(), options, message.properties);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.type);
+    if (message.iD !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.iD);
+    if (message.source !== void 0)
+      writer.tag(3, WireType.LengthDelimited).string(message.source);
+    if (message.properties)
+      Struct.internalBinaryWrite(message.properties, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Subject = new Subject$Type();
+var Resource$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.Resource", [
+      {
+        no: 1,
+        name: "Type",
+        kind: "scalar",
+        jsonName: "Type",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "ID",
+        kind: "scalar",
+        jsonName: "ID",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "Properties", kind: "message", jsonName: "Properties", T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = "";
+    message.iD = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Type = 1 [json_name = "Type"];*/
+        1:
+          message.type = reader.string();
+          break;
+        case /* string ID = 2 [json_name = "ID"];*/
+        2:
+          message.iD = reader.string();
+          break;
+        case /* optional google.protobuf.Struct Properties = 3 [json_name = "Properties"];*/
+        3:
+          message.properties = Struct.internalBinaryRead(reader, reader.uint32(), options, message.properties);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.type);
+    if (message.iD !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.iD);
+    if (message.properties)
+      Struct.internalBinaryWrite(message.properties, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Resource = new Resource$Type();
+var Action$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.Action", [
+      {
+        no: 1,
+        name: "Name",
+        kind: "scalar",
+        jsonName: "Name",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "Properties", kind: "message", jsonName: "Properties", T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Name = 1 [json_name = "Name"];*/
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional google.protobuf.Struct Properties = 2 [json_name = "Properties"];*/
+        2:
+          message.properties = Struct.internalBinaryRead(reader, reader.uint32(), options, message.properties);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.name);
+    if (message.properties)
+      Struct.internalBinaryWrite(message.properties, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Action = new Action$Type();
+var AuthorizationModelRequest$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.AuthorizationModelRequest", [
+      {
+        no: 1,
+        name: "ZoneID",
+        kind: "scalar",
+        jsonName: "ZoneID",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 2, name: "PolicyStore", kind: "message", jsonName: "PolicyStore", T: () => PolicyStore },
+      { no: 3, name: "Principal", kind: "message", jsonName: "Principal", T: () => Principal },
+      { no: 4, name: "Entities", kind: "message", jsonName: "Entities", T: () => Entities }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.zoneID = /* @__PURE__ */ BigInt("0");
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* int64 ZoneID = 1 [json_name = "ZoneID"];*/
+        1:
+          message.zoneID = reader.int64().toBigInt();
+          break;
+        case /* policydecisionpoint.PolicyStore PolicyStore = 2 [json_name = "PolicyStore"];*/
+        2:
+          message.policyStore = PolicyStore.internalBinaryRead(reader, reader.uint32(), options, message.policyStore);
+          break;
+        case /* optional policydecisionpoint.Principal Principal = 3 [json_name = "Principal"];*/
+        3:
+          message.principal = Principal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
+          break;
+        case /* optional policydecisionpoint.Entities Entities = 4 [json_name = "Entities"];*/
+        4:
+          message.entities = Entities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.zoneID !== /* @__PURE__ */ BigInt("0"))
+      writer.tag(1, WireType.Varint).int64(message.zoneID);
+    if (message.policyStore)
+      PolicyStore.internalBinaryWrite(message.policyStore, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.principal)
+      Principal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.entities)
+      Entities.internalBinaryWrite(message.entities, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var AuthorizationModelRequest = new AuthorizationModelRequest$Type();
+var EvaluationRequest$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.EvaluationRequest", [
+      {
+        no: 1,
+        name: "RequestID",
+        kind: "scalar",
+        jsonName: "RequestID",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "Subject", kind: "message", jsonName: "Subject", T: () => Subject },
+      { no: 3, name: "Resource", kind: "message", jsonName: "Resource", T: () => Resource },
+      { no: 4, name: "Action", kind: "message", jsonName: "Action", T: () => Action },
+      { no: 5, name: "Context", kind: "message", jsonName: "Context", T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional string RequestID = 1 [json_name = "RequestID"];*/
+        1:
+          message.requestID = reader.string();
+          break;
+        case /* optional policydecisionpoint.Subject Subject = 2 [json_name = "Subject"];*/
+        2:
+          message.subject = Subject.internalBinaryRead(reader, reader.uint32(), options, message.subject);
+          break;
+        case /* optional policydecisionpoint.Resource Resource = 3 [json_name = "Resource"];*/
+        3:
+          message.resource = Resource.internalBinaryRead(reader, reader.uint32(), options, message.resource);
+          break;
+        case /* optional policydecisionpoint.Action Action = 4 [json_name = "Action"];*/
+        4:
+          message.action = Action.internalBinaryRead(reader, reader.uint32(), options, message.action);
+          break;
+        case /* optional google.protobuf.Struct Context = 5 [json_name = "Context"];*/
+        5:
+          message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.requestID !== void 0)
+      writer.tag(1, WireType.LengthDelimited).string(message.requestID);
+    if (message.subject)
+      Subject.internalBinaryWrite(message.subject, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.resource)
+      Resource.internalBinaryWrite(message.resource, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.action)
+      Action.internalBinaryWrite(message.action, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.context)
+      Struct.internalBinaryWrite(message.context, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var EvaluationRequest = new EvaluationRequest$Type();
+var AuthorizationCheckRequest$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.AuthorizationCheckRequest", [
+      { no: 1, name: "AuthorizationModel", kind: "message", jsonName: "AuthorizationModel", T: () => AuthorizationModelRequest },
+      {
+        no: 2,
+        name: "RequestID",
+        kind: "scalar",
+        jsonName: "RequestID",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "Subject", kind: "message", jsonName: "Subject", T: () => Subject },
+      { no: 4, name: "Resource", kind: "message", jsonName: "Resource", T: () => Resource },
+      { no: 5, name: "Action", kind: "message", jsonName: "Action", T: () => Action },
+      { no: 6, name: "Context", kind: "message", jsonName: "Context", T: () => Struct },
+      { no: 7, name: "Evaluations", kind: "message", jsonName: "Evaluations", repeat: 1, T: () => EvaluationRequest }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.evaluations = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* policydecisionpoint.AuthorizationModelRequest AuthorizationModel = 1 [json_name = "AuthorizationModel"];*/
+        1:
+          message.authorizationModel = AuthorizationModelRequest.internalBinaryRead(reader, reader.uint32(), options, message.authorizationModel);
+          break;
+        case /* optional string RequestID = 2 [json_name = "RequestID"];*/
+        2:
+          message.requestID = reader.string();
+          break;
+        case /* optional policydecisionpoint.Subject Subject = 3 [json_name = "Subject"];*/
+        3:
+          message.subject = Subject.internalBinaryRead(reader, reader.uint32(), options, message.subject);
+          break;
+        case /* optional policydecisionpoint.Resource Resource = 4 [json_name = "Resource"];*/
+        4:
+          message.resource = Resource.internalBinaryRead(reader, reader.uint32(), options, message.resource);
+          break;
+        case /* optional policydecisionpoint.Action Action = 5 [json_name = "Action"];*/
+        5:
+          message.action = Action.internalBinaryRead(reader, reader.uint32(), options, message.action);
+          break;
+        case /* optional google.protobuf.Struct Context = 6 [json_name = "Context"];*/
+        6:
+          message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+          break;
+        case /* repeated policydecisionpoint.EvaluationRequest Evaluations = 7 [json_name = "Evaluations"];*/
+        7:
+          message.evaluations.push(EvaluationRequest.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.authorizationModel)
+      AuthorizationModelRequest.internalBinaryWrite(message.authorizationModel, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    if (message.requestID !== void 0)
+      writer.tag(2, WireType.LengthDelimited).string(message.requestID);
+    if (message.subject)
+      Subject.internalBinaryWrite(message.subject, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.resource)
+      Resource.internalBinaryWrite(message.resource, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.action)
+      Action.internalBinaryWrite(message.action, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    if (message.context)
+      Struct.internalBinaryWrite(message.context, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.evaluations.length; i++)
+      EvaluationRequest.internalBinaryWrite(message.evaluations[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var AuthorizationCheckRequest = new AuthorizationCheckRequest$Type();
+var ReasonResponse$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.ReasonResponse", [
+      {
+        no: 1,
+        name: "Code",
+        kind: "scalar",
+        jsonName: "Code",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "Message",
+        kind: "scalar",
+        jsonName: "Message",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.code = "";
+    message.message = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string Code = 1 [json_name = "Code"];*/
+        1:
+          message.code = reader.string();
+          break;
+        case /* string Message = 2 [json_name = "Message"];*/
+        2:
+          message.message = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.code !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.code);
+    if (message.message !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.message);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ReasonResponse = new ReasonResponse$Type();
+var ContextResponse$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.ContextResponse", [
+      {
+        no: 1,
+        name: "ID",
+        kind: "scalar",
+        jsonName: "ID",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "ReasonAdmin", kind: "message", jsonName: "ReasonAdmin", T: () => ReasonResponse },
+      { no: 3, name: "ReasonUser", kind: "message", jsonName: "ReasonUser", T: () => ReasonResponse }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.iD = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string ID = 1 [json_name = "ID"];*/
+        1:
+          message.iD = reader.string();
+          break;
+        case /* policydecisionpoint.ReasonResponse ReasonAdmin = 2 [json_name = "ReasonAdmin"];*/
+        2:
+          message.reasonAdmin = ReasonResponse.internalBinaryRead(reader, reader.uint32(), options, message.reasonAdmin);
+          break;
+        case /* policydecisionpoint.ReasonResponse ReasonUser = 3 [json_name = "ReasonUser"];*/
+        3:
+          message.reasonUser = ReasonResponse.internalBinaryRead(reader, reader.uint32(), options, message.reasonUser);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.iD !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.iD);
+    if (message.reasonAdmin)
+      ReasonResponse.internalBinaryWrite(message.reasonAdmin, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.reasonUser)
+      ReasonResponse.internalBinaryWrite(message.reasonUser, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ContextResponse = new ContextResponse$Type();
+var EvaluationResponse$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.EvaluationResponse", [
+      {
+        no: 1,
+        name: "Decision",
+        kind: "scalar",
+        jsonName: "Decision",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 2,
+        name: "RequestID",
+        kind: "scalar",
+        jsonName: "RequestID",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "Context", kind: "message", jsonName: "Context", T: () => ContextResponse }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.decision = false;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* bool Decision = 1 [json_name = "Decision"];*/
+        1:
+          message.decision = reader.bool();
+          break;
+        case /* optional string RequestID = 2 [json_name = "RequestID"];*/
+        2:
+          message.requestID = reader.string();
+          break;
+        case /* optional policydecisionpoint.ContextResponse Context = 3 [json_name = "Context"];*/
+        3:
+          message.context = ContextResponse.internalBinaryRead(reader, reader.uint32(), options, message.context);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.decision !== false)
+      writer.tag(1, WireType.Varint).bool(message.decision);
+    if (message.requestID !== void 0)
+      writer.tag(2, WireType.LengthDelimited).string(message.requestID);
+    if (message.context)
+      ContextResponse.internalBinaryWrite(message.context, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var EvaluationResponse = new EvaluationResponse$Type();
+var AuthorizationCheckResponse$Type = class extends MessageType {
+  constructor() {
+    super("policydecisionpoint.AuthorizationCheckResponse", [
+      {
+        no: 1,
+        name: "Decision",
+        kind: "scalar",
+        jsonName: "Decision",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 2,
+        name: "RequestID",
+        kind: "scalar",
+        jsonName: "RequestID",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "Context", kind: "message", jsonName: "Context", T: () => ContextResponse },
+      { no: 4, name: "Evaluations", kind: "message", jsonName: "Evaluations", repeat: 1, T: () => EvaluationResponse }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.decision = false;
+    message.evaluations = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target != null ? target : this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* bool Decision = 1 [json_name = "Decision"];*/
+        1:
+          message.decision = reader.bool();
+          break;
+        case /* optional string RequestID = 2 [json_name = "RequestID"];*/
+        2:
+          message.requestID = reader.string();
+          break;
+        case /* optional policydecisionpoint.ContextResponse Context = 3 [json_name = "Context"];*/
+        3:
+          message.context = ContextResponse.internalBinaryRead(reader, reader.uint32(), options, message.context);
+          break;
+        case /* repeated policydecisionpoint.EvaluationResponse Evaluations = 4 [json_name = "Evaluations"];*/
+        4:
+          message.evaluations.push(EvaluationResponse.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.decision !== false)
+      writer.tag(1, WireType.Varint).bool(message.decision);
+    if (message.requestID !== void 0)
+      writer.tag(2, WireType.LengthDelimited).string(message.requestID);
+    if (message.context)
+      ContextResponse.internalBinaryWrite(message.context, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.evaluations.length; i++)
+      EvaluationResponse.internalBinaryWrite(message.evaluations[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var AuthorizationCheckResponse = new AuthorizationCheckResponse$Type();
+var V1PDPService = new import_runtime_rpc.ServiceType("policydecisionpoint.V1PDPService", [
+  { name: "AuthorizationCheck", options: {}, I: AuthorizationCheckRequest, O: AuthorizationCheckResponse }
+]);
+
+// src/internal/az/azreq/grpc/v1/generated/proto/v1/pdp.client.ts
+var import_runtime_rpc2 = require("@protobuf-ts/runtime-rpc");
+var V1PDPServiceClient = class {
+  constructor(_transport) {
+    this._transport = _transport;
+    this.typeName = V1PDPService.typeName;
+    this.methods = V1PDPService.methods;
+    this.options = V1PDPService.options;
+  }
+  /**
+   * @generated from protobuf rpc: AuthorizationCheck(policydecisionpoint.AuthorizationCheckRequest) returns (policydecisionpoint.AuthorizationCheckResponse);
+   */
+  authorizationCheck(input, options) {
+    const method = this.methods[0], opt = this._transport.mergeOptions(options);
+    return (0, import_runtime_rpc2.stackIntercept)("unary", this._transport, method, opt, input);
+  }
+};
+
+// src/internal/az/azreq/grpc/v1/pdp_grpc_mapper.ts
+function mapPolicyStoreToGrpcPolicyStore(policyStore) {
+  if (!policyStore) return null;
+  return PolicyStore.create({
+    kind: policyStore.kind,
+    iD: policyStore.id
+  });
+}
+function mapPrincipalToGrpcPrincipal(principal) {
+  if (!principal) return null;
+  return Principal.create({
+    type: principal.type,
+    iD: principal.id,
+    source: principal.source
+  });
+}
+function mapEntitiesToGrpcEntities(entities) {
+  var _a;
+  if (!entities) return null;
+  return Entities.create({
+    schema: entities.schema,
+    items: (_a = entities.items) == null ? void 0 : _a.map((item) => Struct.fromJson(item))
+  });
+}
+function mapSubjectToGrpcSubject(subject) {
+  if (!subject) return null;
+  return Subject.create({
+    type: subject.type,
+    iD: subject.id,
+    source: subject.source,
+    properties: subject.properties ? Struct.fromJson(subject.properties) : void 0
+  });
+}
+function mapResourceToGrpcResource(resource) {
+  if (!resource) return null;
+  return Resource.create({
+    type: resource.type,
+    iD: resource.id,
+    properties: resource.properties ? Struct.fromJson(resource.properties) : void 0
+  });
+}
+function mapActionToGrpcAction(action) {
+  if (!action) return null;
+  return Action.create({
+    name: action.name,
+    properties: action.properties ? Struct.fromJson(action.properties) : void 0
+  });
+}
+function mapEvaluationToGrpcEvaluationRequest(evaluation) {
+  var _a, _b, _c;
+  if (!evaluation) return null;
+  return EvaluationRequest.create({
+    requestID: evaluation.request_id,
+    subject: evaluation.subject ? (_a = mapSubjectToGrpcSubject(evaluation.subject)) != null ? _a : void 0 : void 0,
+    resource: evaluation.resource ? (_b = mapResourceToGrpcResource(evaluation.resource)) != null ? _b : void 0 : void 0,
+    action: evaluation.action ? (_c = mapActionToGrpcAction(evaluation.action)) != null ? _c : void 0 : void 0,
+    context: evaluation.context ? Struct.fromJson(evaluation.context) : void 0
+  });
+}
+function mapAuthZModelToGrpcAuthorizationModelRequest(azModel) {
+  var _a, _b, _c;
+  if (!azModel) return null;
+  return AuthorizationModelRequest.create({
+    zoneID: BigInt(azModel.zone_id),
+    policyStore: azModel.policy_store ? (_a = mapPolicyStoreToGrpcPolicyStore(azModel.policy_store)) != null ? _a : void 0 : void 0,
+    principal: azModel.principal ? (_b = mapPrincipalToGrpcPrincipal(azModel.principal)) != null ? _b : void 0 : void 0,
+    entities: azModel.entities ? (_c = mapEntitiesToGrpcEntities(azModel.entities)) != null ? _c : void 0 : void 0
+  });
+}
+function mapAZRequestToGrpcAuthorizationCheckRequest(azRequest) {
+  var _a, _b, _c, _d, _e;
+  return AuthorizationCheckRequest.create({
+    requestID: azRequest.request_id,
+    authorizationModel: azRequest.authorization_model ? (_a = mapAuthZModelToGrpcAuthorizationModelRequest(
+      azRequest.authorization_model
+    )) != null ? _a : void 0 : void 0,
+    subject: azRequest.subject ? (_b = mapSubjectToGrpcSubject(azRequest.subject)) != null ? _b : void 0 : void 0,
+    resource: azRequest.resource ? (_c = mapResourceToGrpcResource(azRequest.resource)) != null ? _c : void 0 : void 0,
+    action: azRequest.action ? (_d = mapActionToGrpcAction(azRequest.action)) != null ? _d : void 0 : void 0,
+    context: azRequest.context ? Struct.fromJson(azRequest.context) : void 0,
+    evaluations: (_e = azRequest.evaluations) == null ? void 0 : _e.map(
+      (evaluation) => mapEvaluationToGrpcEvaluationRequest(evaluation)
+    )
+  });
+}
+function mapGrpcReasonResponseToReasonResponse(reasonResponse) {
+  if (!reasonResponse) return null;
+  return {
+    Code: reasonResponse.code,
+    Message: reasonResponse.message
+  };
+}
+function mapGrpcContextResponseToContextResponse(contextResponse) {
+  if (!contextResponse) return null;
+  return {
+    ID: contextResponse.iD,
+    ReasonAdmin: contextResponse.reasonAdmin ? mapGrpcReasonResponseToReasonResponse(contextResponse.reasonAdmin) : void 0,
+    ReasonUser: contextResponse.reasonUser ? mapGrpcReasonResponseToReasonResponse(contextResponse.reasonUser) : null
+  };
+}
+function mapGrpcEvaluationResponseToEvaluationResponse(evaluationResponse) {
+  if (!evaluationResponse) return null;
+  return {
+    Decision: evaluationResponse.decision,
+    RequestID: evaluationResponse.requestID || "",
+    Context: evaluationResponse.context ? mapGrpcContextResponseToContextResponse(evaluationResponse.context) : void 0
+  };
+}
+function mapGrpcAuthorizationCheckResponseToAZResponse(response) {
+  var _a;
+  return {
+    Decision: response.decision,
+    RequestID: response.requestID || "",
+    Context: response.context ? mapGrpcContextResponseToContextResponse(response.context) : void 0,
+    Evaluations: (_a = response.evaluations) == null ? void 0 : _a.map(
+      (evaluation) => mapGrpcEvaluationResponseToEvaluationResponse(evaluation)
+    )
+  };
+}
+
+// src/internal/az/azreq/grpc/v1/pdp_client.ts
+var import_runtime_rpc3 = require("@protobuf-ts/runtime-rpc");
+var import_grpc_transport = require("@protobuf-ts/grpc-transport");
+var import_grpc_js = require("@grpc/grpc-js");
+var PDPClient = class {
+  /**
+   * Creates a new PDPClient.
+   * @param endpoint - The gRPC server endpoint.
+   */
+  constructor(endpoint) {
+    const transport = new import_grpc_transport.GrpcTransport({
+      host: endpoint,
+      channelCredentials: import_grpc_js.ChannelCredentials.createInsecure()
+    });
+    this.client = new V1PDPServiceClient(transport);
+  }
+  /**
+   * Checks the authorization request with the PDP service.
+   * @param request - The authorization request.
+   * @returns A promise that resolves to the authorization response.
+   */
+  async authorizationCheck(request) {
+    if (!request) {
+      throw new Error("Invalid request: request cannot be null or undefined");
+    }
+    const grpcRequest = mapAZRequestToGrpcAuthorizationCheckRequest(request);
+    try {
+      const response = await this.client.authorizationCheck(grpcRequest).response;
+      return mapGrpcAuthorizationCheckResponseToAZResponse(response);
+    } catch (err) {
+      if (err instanceof import_runtime_rpc3.RpcError) {
+        throw new Error(`gRPC call failed: ${err.message}`);
+      }
+      throw err;
+    }
+  }
+};
+
+// src/azclient.ts
+var AZClient = class {
+  /**
+   * Creates a new AZClient.
+   * @param opts - Optional configuration options.
+   */
+  constructor(...opts) {
+    this.azConfig = {
+      pdpEndpoint: {
+        endpoint: "localhost",
+        port: 9094
+      }
+    };
+    opts.forEach((opt) => opt(this.azConfig));
+  }
+  /**
+   * Checks the input authorization request with the authorization server.
+   * @param req - The authorization request.
+   * @returns A tuple containing:
+   *   - A boolean indicating the decision (true if authorized, false otherwise).
+   *   - The full authorization response.
+   *   - An error, if any.
+   */
+  async check(req) {
+    var _a, _b;
+    const target = `${(_a = this.azConfig.pdpEndpoint) == null ? void 0 : _a.endpoint}:${(_b = this.azConfig.pdpEndpoint) == null ? void 0 : _b.port}`;
+    const pdpClient = new PDPClient(target);
+    try {
+      const response = await pdpClient.authorizationCheck(req);
+      return { decision: response.Decision, response, error: null };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return { decision: false, response: null, error };
+    }
+  }
+};
+
+// src/az/azreq/builder_action.ts
+var import_lodash = __toESM(require("lodash"));
+var ActionBuilder = class {
+  /**
+   * Creates a new ActionBuilder instance.
+   * @param name - The name of the action.
+   */
+  constructor(name) {
+    this.action = {
+      name
+    };
+  }
+  /**
+   * Sets a property of the action.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The ActionBuilder instance for method chaining.
+   */
+  withProperty(key, value) {
+    if (!this.action.properties) {
+      this.action.properties = {};
+    }
+    this.action.properties[key] = value;
+    return this;
+  }
+  /**
+   * Builds the Action object.
+   * @returns The constructed Action object.
+   */
+  build() {
+    return import_lodash.default.cloneDeep(this.action);
+  }
+};
+
+// src/az/azreq/builder_context.ts
+var import_lodash2 = __toESM(require("lodash"));
+var ContextBuilder = class {
+  /**
+   * Creates a new ContextBuilder instance.
+   */
+  constructor() {
+    this.context = {};
+  }
+  /**
+   * Sets a property of the context.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The ContextBuilder instance for method chaining.
+   */
+  withProperty(key, value) {
+    if (!this.context) {
+      this.context = {};
+    }
+    this.context[key] = value;
+    return this;
+  }
+  /**
+   * Builds the Context object.
+   * @returns The constructed Context object (a map of key-value pairs).
+   */
+  build() {
+    return import_lodash2.default.cloneDeep(this.context);
+  }
+};
+
+// src/az/azreq/builder_evaluation.ts
+var import_lodash3 = __toESM(require("lodash"));
+var EvaluationBuilder = class {
+  /**
+   * Creates a new EvaluationBuilder instance.
+   * @param subject - The subject of the evaluation.
+   * @param resource - The resource of the evaluation.
+   * @param action - The action of the evaluation.
+   */
+  constructor(subject, resource, action) {
+    this.azEvaluation = {
+      subject,
+      resource,
+      action
+    };
+  }
+  /**
+   * Sets the request ID of the evaluation.
+   * @param requestID - The request ID.
+   * @returns The EvaluationBuilder instance for method chaining.
+   */
+  withRequestID(requestID) {
+    this.azEvaluation.request_id = requestID;
+    return this;
+  }
+  /**
+   * Sets the context of the evaluation.
+   * @param context - The context (a map of key-value pairs).
+   * @returns The EvaluationBuilder instance for method chaining.
+   */
+  withContext(context) {
+    this.azEvaluation.context = context;
+    return this;
+  }
+  /**
+   * Builds the Evaluation object.
+   * @returns The constructed Evaluation object.
+   */
+  build() {
+    return import_lodash3.default.cloneDeep(this.azEvaluation);
+  }
+};
+
+// src/az/azreq/builder_principal.ts
+var import_lodash4 = __toESM(require("lodash"));
+var PrincipalDefaultKind = "user";
+var PrincipalBuilder = class {
+  /**
+   * Creates a new PrincipalBuilder instance.
+   * @param id - The ID of the principal.
+   */
+  constructor(id) {
+    this.principal = {
+      type: PrincipalDefaultKind,
+      id
+    };
+  }
+  /**
+   * Sets the kind of the principal.
+   * @param kind - The kind of the principal.
+   * @returns The PrincipalBuilder instance for method chaining.
+   */
+  withKind(kind) {
+    this.principal.type = kind;
+    return this;
+  }
+  /**
+   * Sets the source of the principal.
+   * @param source - The source of the principal.
+   * @returns The PrincipalBuilder instance for method chaining.
+   */
+  withSource(source) {
+    this.principal.source = source;
+    return this;
+  }
+  /**
+   * Builds the Principal object.
+   * @returns The constructed Principal object.
+   */
+  build() {
+    return import_lodash4.default.cloneDeep(this.principal);
+  }
+};
+
+// src/az/azreq/builder_request_composed.ts
+var import_lodash5 = __toESM(require("lodash"));
+var AZRequestBuilder = class {
+  /**
+   * Creates a new AZRequestBuilder instance.
+   * @param zoneID - The zone ID.
+   * @param ledgerID - The ledger ID.
+   */
+  constructor(zoneID, ledgerID) {
+    this.azRequest = {
+      authorization_model: {
+        zone_id: zoneID,
+        policy_store: {
+          kind: "ledger",
+          id: ledgerID
+        },
+        entities: {
+          schema: "",
+          items: []
+        }
+      },
+      evaluations: []
+    };
+  }
+  /**
+   * Sets the principal of the AZRequest.
+   * @param principal - The principal object.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withPrincipal(principal) {
+    this.azRequest.authorization_model.principal = principal;
+    return this;
+  }
+  /**
+   * Sets the request ID of the AZRequest.
+   * @param requestID - The request ID.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withRequestID(requestID) {
+    this.azRequest.request_id = requestID;
+    return this;
+  }
+  /**
+   * Sets the subject of the AZRequest.
+   * @param subject - The subject object.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withSubject(subject) {
+    this.azRequest.subject = subject;
+    return this;
+  }
+  /**
+   * Sets the resource of the AZRequest.
+   * @param resource - The resource object.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withResource(resource) {
+    this.azRequest.resource = resource;
+    return this;
+  }
+  /**
+   * Sets the action of the AZRequest.
+   * @param action - The action object.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withAction(action) {
+    this.azRequest.action = action;
+    return this;
+  }
+  /**
+   * Sets the context of the AZRequest.
+   * @param context - The context object (a map of key-value pairs).
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withContext(context) {
+    this.azRequest.context = context;
+    return this;
+  }
+  /**
+   * Sets the entities map to the AZRequest.
+   * @param schema - The schema of the entities.
+   * @param entities - The entities map.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withEntitiesMap(schema, entities) {
+    this.azRequest.authorization_model.entities.schema = schema;
+    this.azRequest.authorization_model.entities.items = [entities];
+    return this;
+  }
+  /**
+   * Sets the entities items to the AZRequest.
+   * @param schema - The schema of the entities.
+   * @param entities - The entities items (array of maps).
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withEntitiesItems(schema, entities) {
+    this.azRequest.authorization_model.entities.schema = schema;
+    this.azRequest.authorization_model.entities.items = entities;
+    if (!this.azRequest.authorization_model.entities.items) {
+      this.azRequest.authorization_model.entities.items = [];
+    }
+    return this;
+  }
+  /**
+   * Adds an evaluation to the AZRequest.
+   * @param evaluation - The evaluation object.
+   * @returns The AZRequestBuilder instance for method chaining.
+   */
+  withEvaluation(evaluation) {
+    var _a;
+    (_a = this.azRequest.evaluations) == null ? void 0 : _a.push(evaluation);
+    return this;
+  }
+  /**
+   * Builds the AZRequest object.
+   * @returns The constructed AZRequest object.
+   */
+  build() {
+    return import_lodash5.default.cloneDeep(this.azRequest);
+  }
+};
+
+// src/az/azreq/model.ts
+var ActorType = /* @__PURE__ */ ((ActorType2) => {
+  ActorType2["UserType"] = "USER";
+  ActorType2["RoleActorType"] = "ROLE-ACTOR";
+  ActorType2["TwinActorType"] = "TWIN-ACTOR";
+  return ActorType2;
+})(ActorType || {});
+
+// src/az/azreq/builder_subject.ts
+var import_lodash6 = __toESM(require("lodash"));
+var SubjectDefaultKind = "user";
+var SubjectBuilder = class {
+  /**
+   * Creates a new SubjectBuilder instance.
+   * @param id - The ID of the subject.
+   */
+  constructor(id) {
+    this.subject = {
+      type: SubjectDefaultKind,
+      id
+    };
+  }
+  /**
+   * Sets the kind of the subject.
+   * @param kind - The kind of the subject.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withKind(kind) {
+    this.subject.type = kind;
+    return this;
+  }
+  /**
+   * Sets the source of the subject.
+   * @param source - The source of the subject.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withSource(source) {
+    this.subject.source = source;
+    return this;
+  }
+  /**
+   * Sets a property of the subject.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withProperty(key, value) {
+    if (!this.subject.properties) {
+      this.subject.properties = {};
+    }
+    this.subject.properties[key] = value;
+    return this;
+  }
+  /**
+   * Sets the type of the subject to UserType.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withUserType() {
+    this.subject.type = "USER" /* UserType */;
+    return this;
+  }
+  /**
+   * Sets the type of the subject to RoleActorType.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withRoleActorType() {
+    this.subject.type = "ROLE-ACTOR" /* RoleActorType */;
+    return this;
+  }
+  /**
+   * Sets the type of the subject to TwinActorType.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withTwinActorType() {
+    this.subject.type = "TWIN-ACTOR" /* TwinActorType */;
+    return this;
+  }
+  /**
+   * Sets the type of the subject.
+   * @param subType - The type of the subject.
+   * @returns The SubjectBuilder instance for method chaining.
+   */
+  withType(subType) {
+    this.subject.type = subType;
+    return this;
+  }
+  /**
+   * Builds the Subject object.
+   * @returns The constructed Subject object.
+   */
+  build() {
+    return import_lodash6.default.cloneDeep(this.subject);
+  }
+};
+
+// src/az/azreq/builder_resource.ts
+var import_lodash7 = __toESM(require("lodash"));
+var ResourceBuilder = class {
+  /**
+   * Creates a new ResourceBuilder instance.
+   * @param kind - The kind (type) of the resource.
+   */
+  constructor(kind) {
+    this.resource = {
+      type: kind
+    };
+  }
+  /**
+   * Sets the ID of the resource.
+   * @param id - The ID of the resource.
+   * @returns The ResourceBuilder instance for method chaining.
+   */
+  withID(id) {
+    this.resource.id = id;
+    return this;
+  }
+  /**
+   * Sets a property of the resource.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The ResourceBuilder instance for method chaining.
+   */
+  withProperty(key, value) {
+    if (!this.resource.properties) {
+      this.resource.properties = {};
+    }
+    this.resource.properties[key] = value;
+    return this;
+  }
+  /**
+   * Builds the Resource object.
+   * @returns The constructed Resource object.
+   */
+  build() {
+    return import_lodash7.default.cloneDeep(this.resource);
+  }
+};
+
+// src/az/azreq/builder_request_atomic.ts
+var AZAtomicRequestBuilder = class {
+  /**
+   * Creates a new AZAtomicRequestBuilder instance.
+   * @param zoneID - The zone ID.
+   * @param ledgerID - The ledger ID.
+   * @param subjectID - The subject ID.
+   * @param resourceKind - The resource kind.
+   * @param actionName - The action name.
+   */
+  constructor(zoneID, ledgerID, subjectID, resourceKind, actionName) {
+    this.azRequestBuilder = new AZRequestBuilder(zoneID, ledgerID);
+    this.azSubjectBuilder = new SubjectBuilder(subjectID);
+    this.azResourceBuilder = new ResourceBuilder(resourceKind);
+    this.azActionBuilder = new ActionBuilder(actionName);
+    this.azContextBuilder = new ContextBuilder();
+  }
+  /**
+   * Sets the entities map to the AZRequest.
+   * @param schema - The schema of the entities.
+   * @param entities - The entities map.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withEntitiesMap(schema, entities) {
+    this.azRequestBuilder.withEntitiesMap(schema, entities);
+    return this;
+  }
+  /**
+   * Sets the entities items to the AZRequest.
+   * @param schema - The schema of the entities.
+   * @param entities - The entities items.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withEntitiesItems(schema, entities) {
+    this.azRequestBuilder.withEntitiesItems(schema, entities);
+    return this;
+  }
+  /**
+   * Sets the request ID of the AZRequest.
+   * @param requestID - The request ID.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withRequestID(requestID) {
+    this.requestID = requestID;
+    return this;
+  }
+  /**
+   * Sets the principal of the AZRequest.
+   * @param principal - The principal.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withPrincipal(principal) {
+    this.principal = principal;
+    return this;
+  }
+  /**
+   * Sets the kind of the subject for the AZRequest.
+   * @param kind - The subject kind.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectKind(kind) {
+    this.azSubjectBuilder.withKind(kind);
+    return this;
+  }
+  /**
+   * Sets the source of the subject for the AZRequest.
+   * @param source - The subject source.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectSource(source) {
+    this.azSubjectBuilder.withSource(source);
+    return this;
+  }
+  /**
+   * Sets a property of the subject for the AZRequest.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectProperty(key, value) {
+    this.azSubjectBuilder.withProperty(key, value);
+    return this;
+  }
+  /**
+   * Sets the ID of the resource for the AZRequest.
+   * @param id - The resource ID.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withResourceID(id) {
+    this.azResourceBuilder.withID(id);
+    return this;
+  }
+  /**
+   * Sets a property of the resource for the AZRequest.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withResourceProperty(key, value) {
+    this.azResourceBuilder.withProperty(key, value);
+    return this;
+  }
+  /**
+   * Sets a property of the action for the AZRequest.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withActionProperty(key, value) {
+    this.azActionBuilder.withProperty(key, value);
+    return this;
+  }
+  /**
+   * Sets a property of the context for the AZRequest.
+   * @param key - The property key.
+   * @param value - The property value.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withContextProperty(key, value) {
+    this.azContextBuilder.withProperty(key, value);
+    return this;
+  }
+  /**
+   * Sets the type of the subject to UserType.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectUserType() {
+    this.azSubjectBuilder.withKind("USER" /* UserType */);
+    return this;
+  }
+  /**
+   * Sets the type of the subject to RoleActorType.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectRoleActorType() {
+    this.azSubjectBuilder.withKind("ROLE-ACTOR" /* RoleActorType */);
+    return this;
+  }
+  /**
+   * Sets the type of the subject to TwinActorType.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectTwinActorType() {
+    this.azSubjectBuilder.withKind("TWIN-ACTOR" /* TwinActorType */);
+    return this;
+  }
+  /**
+   * Sets the type of the subject.
+   * @param kind - The type of the subject.
+   * @returns The AZAtomicRequestBuilder instance for method chaining.
+   */
+  withSubjectType(kind) {
+    this.azSubjectBuilder.withKind(kind);
+    return this;
+  }
+  /**
+   * Builds the AZAtomicRequest object.
+   * @returns The constructed AZRequest object.
+   */
+  build() {
+    const subject = this.azSubjectBuilder.build();
+    const resource = this.azResourceBuilder.build();
+    const action = this.azActionBuilder.build();
+    const context = this.azContextBuilder.build();
+    this.azRequestBuilder.withPrincipal(this.principal).withRequestID(this.requestID).withSubject(subject).withResource(resource).withAction(action).withContext(context);
+    return this.azRequestBuilder.build();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AZAtomicRequestBuilder,
+  AZClient,
+  AZRequestBuilder,
+  ActionBuilder,
+  ActorType,
+  ContextBuilder,
+  EvaluationBuilder,
+  PrincipalBuilder,
+  ResourceBuilder,
+  SubjectBuilder,
+  withEndpoint
+});
+//# sourceMappingURL=index.js.map