@openfeature/flagd-provider 0.7.4 → 0.7.6

package/index.cjs

@@ -5,8 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var grpc = require('@grpc/grpc-js');
 var jsSdk = require('@openfeature/js-sdk');
 var grpcTransport = require('@protobuf-ts/grpc-transport');
+var LRU = require('lru-cache');
+var runtime = require('@protobuf-ts/runtime');
 var runtimeRpc = require('@protobuf-ts/runtime-rpc');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -26,11 +30,21 @@ function _interopNamespace(e) {
 }
 
 var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
+var LRU__default = /*#__PURE__*/_interopDefaultLegacy(LRU);
+
+const BASE_EVENT_STREAM_RETRY_BACKOFF_MS = 1000;
+const DEFAULT_MAX_EVENT_STREAM_RETRIES = 5;
+const EVENT_CONFIGURATION_CHANGE = 'configuration_change';
+const EVENT_PROVIDER_READY = 'provider_ready';
+const DEFAULT_MAX_CACHE_SIZE = 1000;
 
 const DEFAULT_CONFIG = {
     host: 'localhost',
     port: 8013,
     tls: false,
+    cache: 'lru',
+    maxCacheSize: DEFAULT_MAX_CACHE_SIZE,
+    maxEventStreamRetries: DEFAULT_MAX_EVENT_STREAM_RETRIES,
 };
 var ENV_VAR;
 (function (ENV_VAR) {
@@ -38,10 +52,13 @@ var ENV_VAR;
     ENV_VAR["FLAGD_PORT"] = "FLAGD_PORT";
     ENV_VAR["FLAGD_TLS"] = "FLAGD_TLS";
     ENV_VAR["FLAGD_SOCKET_PATH"] = "FLAGD_SOCKET_PATH";
+    ENV_VAR["FLAGD_CACHE"] = "FLAGD_CACHE";
+    ENV_VAR["FLAGD_MAX_CACHE_SIZE"] = "FLAGD_MAX_CACHE_SIZE";
+    ENV_VAR["FLAGD_MAX_EVENT_STREAM_RETRIES"] = "FLAGD_MAX_EVENT_STREAM_RETRIES";
 })(ENV_VAR || (ENV_VAR = {}));
 const getEnvVarConfig = () => {
     var _a;
-    return (Object.assign(Object.assign(Object.assign(Object.assign({}, (process.env[ENV_VAR.FLAGD_HOST] && {
+    return (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (process.env[ENV_VAR.FLAGD_HOST] && {
         host: process.env[ENV_VAR.FLAGD_HOST],
     })), (Number(process.env[ENV_VAR.FLAGD_PORT]) && {
         port: Number(process.env[ENV_VAR.FLAGD_PORT]),
@@ -49,6 +66,12 @@ const getEnvVarConfig = () => {
         tls: ((_a = process.env[ENV_VAR.FLAGD_TLS]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'true',
     })), (process.env[ENV_VAR.FLAGD_SOCKET_PATH] && {
         socketPath: process.env[ENV_VAR.FLAGD_SOCKET_PATH],
+    })), ((process.env[ENV_VAR.FLAGD_CACHE] === 'lru' || process.env[ENV_VAR.FLAGD_CACHE] === 'disabled') && {
+        cache: process.env[ENV_VAR.FLAGD_CACHE],
+    })), (process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE] && {
+        maxCacheSize: Number(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE]),
+    })), (process.env[ENV_VAR.FLAGD_MAX_EVENT_STREAM_RETRIES] && {
+        maxEventStreamRetries: Number(process.env[ENV_VAR.FLAGD_MAX_EVENT_STREAM_RETRIES]),
     })));
 };
 function getConfig(options = {}) {
@@ -80,2928 +103,6 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-/**
- * Get the type of a JSON value.
- * Distinguishes between array, null and object.
- */
-function typeofJsonValue(value) {
-    let t = typeof value;
-    if (t == "object") {
-        if (Array.isArray(value))
-            return "array";
-        if (value === null)
-            return "null";
-    }
-    return t;
-}
-/**
- * Is this a JSON object (instead of an array or null)?
- */
-function isJsonObject(value) {
-    return value !== null && typeof value == "object" && !Array.isArray(value);
-}
-
-// lookup table from base64 character to byte
-let encTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
-// lookup table from base64 character *code* to byte because lookup by number is fast
-let decTable = [];
-for (let i = 0; i < encTable.length; i++)
-    decTable[encTable[i].charCodeAt(0)] = i;
-// support base64url variants
-decTable["-".charCodeAt(0)] = encTable.indexOf("+");
-decTable["_".charCodeAt(0)] = encTable.indexOf("/");
-/**
- * Decodes a base64 string to a byte array.
- *
- * - ignores white-space, including line breaks and tabs
- * - allows inner padding (can decode concatenated base64 strings)
- * - does not require padding
- * - understands base64url encoding:
- *   "-" instead of "+",
- *   "_" instead of "/",
- *   no padding
- */
-function base64decode(base64Str) {
-    // estimate byte size, not accounting for inner padding and whitespace
-    let es = base64Str.length * 3 / 4;
-    // if (es % 3 !== 0)
-    // throw new Error('invalid base64 string');
-    if (base64Str[base64Str.length - 2] == '=')
-        es -= 2;
-    else if (base64Str[base64Str.length - 1] == '=')
-        es -= 1;
-    let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
-    groupPos = 0, // position in base64 group
-    b, // current byte
-    p = 0 // previous byte
-    ;
-    for (let i = 0; i < base64Str.length; i++) {
-        b = decTable[base64Str.charCodeAt(i)];
-        if (b === undefined) {
-            // noinspection FallThroughInSwitchStatementJS
-            switch (base64Str[i]) {
-                case '=':
-                    groupPos = 0; // reset state when padding found
-                case '\n':
-                case '\r':
-                case '\t':
-                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);
-}
-/**
- * Encodes a byte array to a base64 string.
- * Adds padding at the end.
- * Does not insert newlines.
- */
-function base64encode(bytes) {
-    let base64 = '', groupPos = 0, // position in base64 group
-    b, // current byte
-    p = 0; // carry over from previous byte
-    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;
-        }
-    }
-    // padding required?
-    if (groupPos) {
-        base64 += encTable[p];
-        base64 += '=';
-        if (groupPos == 1)
-            base64 += '=';
-    }
-    return base64;
-}
-
-/**
- * This handler implements the default behaviour for unknown fields.
- * When reading data, unknown fields are stored on the message, in a
- * symbol property.
- * When writing data, the symbol property is queried and unknown fields
- * are serialized into the output again.
- */
-var UnknownFieldHandler;
-(function (UnknownFieldHandler) {
-    /**
-     * The symbol used to store unknown fields for a message.
-     * The property must conform to `UnknownFieldContainer`.
-     */
-    UnknownFieldHandler.symbol = Symbol.for("protobuf-ts/unknown");
-    /**
-     * Store an unknown field during binary read directly on the message.
-     * This method is compatible with `BinaryReadOptions.readUnknownField`.
-     */
-    UnknownFieldHandler.onRead = (typeName, message, fieldNo, wireType, data) => {
-        let container = is(message) ? message[UnknownFieldHandler.symbol] : message[UnknownFieldHandler.symbol] = [];
-        container.push({ no: fieldNo, wireType, data });
-    };
-    /**
-     * Write unknown fields stored for the message to the writer.
-     * This method is compatible with `BinaryWriteOptions.writeUnknownFields`.
-     */
-    UnknownFieldHandler.onWrite = (typeName, message, writer) => {
-        for (let { no, wireType, data } of UnknownFieldHandler.list(message))
-            writer.tag(no, wireType).raw(data);
-    };
-    /**
-     * List unknown fields stored for the message.
-     * Note that there may be multiples fields with the same number.
-     */
-    UnknownFieldHandler.list = (message, fieldNo) => {
-        if (is(message)) {
-            let all = message[UnknownFieldHandler.symbol];
-            return fieldNo ? all.filter(uf => uf.no == fieldNo) : all;
-        }
-        return [];
-    };
-    /**
-     * Returns the last unknown field by field number.
-     */
-    UnknownFieldHandler.last = (message, fieldNo) => UnknownFieldHandler.list(message, fieldNo).slice(-1)[0];
-    const is = (message) => message && Array.isArray(message[UnknownFieldHandler.symbol]);
-})(UnknownFieldHandler || (UnknownFieldHandler = {}));
-/**
- * Protobuf binary format wire types.
- *
- * A wire type provides just enough information to find the length of the
- * following value.
- *
- * See https://developers.google.com/protocol-buffers/docs/encoding#structure
- */
-var WireType;
-(function (WireType) {
-    /**
-     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
-     */
-    WireType[WireType["Varint"] = 0] = "Varint";
-    /**
-     * Used for fixed64, sfixed64, double.
-     * Always 8 bytes with little-endian byte order.
-     */
-    WireType[WireType["Bit64"] = 1] = "Bit64";
-    /**
-     * Used for string, bytes, embedded messages, packed repeated fields
-     *
-     * Only repeated numeric types (types which use the varint, 32-bit,
-     * or 64-bit wire types) can be packed. In proto3, such fields are
-     * packed by default.
-     */
-    WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
-    /**
-     * Used for groups
-     * @deprecated
-     */
-    WireType[WireType["StartGroup"] = 3] = "StartGroup";
-    /**
-     * Used for groups
-     * @deprecated
-     */
-    WireType[WireType["EndGroup"] = 4] = "EndGroup";
-    /**
-     * Used for fixed32, sfixed32, float.
-     * Always 4 bytes with little-endian byte order.
-     */
-    WireType[WireType["Bit32"] = 5] = "Bit32";
-})(WireType || (WireType = {}));
-
-// Copyright 2008 Google Inc.  All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Code generated by the Protocol Buffer compiler is owned by the owner
-// of the input file used when generating it.  This code is not
-// standalone and requires a support library to be linked with it.  This
-// support library is itself covered by the above license.
-/**
- * Read a 64 bit varint as two JS numbers.
- *
- * Returns tuple:
- * [0]: low bits
- * [0]: high bits
- *
- * Copyright 2008 Google Inc.  All rights reserved.
- *
- * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
- */
-function varint64read() {
-    let lowBits = 0;
-    let highBits = 0;
-    for (let shift = 0; shift < 28; shift += 7) {
-        let b = this.buf[this.pos++];
-        lowBits |= (b & 0x7F) << shift;
-        if ((b & 0x80) == 0) {
-            this.assertBounds();
-            return [lowBits, highBits];
-        }
-    }
-    let middleByte = this.buf[this.pos++];
-    // last four bits of the first 32 bit number
-    lowBits |= (middleByte & 0x0F) << 28;
-    // 3 upper bits are part of the next 32 bit number
-    highBits = (middleByte & 0x70) >> 4;
-    if ((middleByte & 0x80) == 0) {
-        this.assertBounds();
-        return [lowBits, highBits];
-    }
-    for (let shift = 3; shift <= 31; shift += 7) {
-        let b = this.buf[this.pos++];
-        highBits |= (b & 0x7F) << shift;
-        if ((b & 0x80) == 0) {
-            this.assertBounds();
-            return [lowBits, highBits];
-        }
-    }
-    throw new Error('invalid varint');
-}
-/**
- * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
- *
- * Copyright 2008 Google Inc.  All rights reserved.
- *
- * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
- */
-function varint64write(lo, hi, bytes) {
-    for (let i = 0; i < 28; i = i + 7) {
-        const shift = lo >>> i;
-        const hasNext = !((shift >>> 7) == 0 && hi == 0);
-        const byte = (hasNext ? shift | 0x80 : shift) & 0xFF;
-        bytes.push(byte);
-        if (!hasNext) {
-            return;
-        }
-    }
-    const splitBits = ((lo >>> 28) & 0x0F) | ((hi & 0x07) << 4);
-    const hasMoreBits = !((hi >> 3) == 0);
-    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xFF);
-    if (!hasMoreBits) {
-        return;
-    }
-    for (let i = 3; i < 31; i = i + 7) {
-        const shift = hi >>> i;
-        const hasNext = !((shift >>> 7) == 0);
-        const byte = (hasNext ? shift | 0x80 : shift) & 0xFF;
-        bytes.push(byte);
-        if (!hasNext) {
-            return;
-        }
-    }
-    bytes.push((hi >>> 31) & 0x01);
-}
-// constants for binary math
-const TWO_PWR_32_DBL$1 = (1 << 16) * (1 << 16);
-/**
- * Parse decimal string of 64 bit integer value as two JS numbers.
- *
- * Returns tuple:
- * [0]: minus sign?
- * [1]: low bits
- * [2]: high bits
- *
- * Copyright 2008 Google Inc.
- */
-function int64fromString(dec) {
-    // Check for minus sign.
-    let minus = dec[0] == '-';
-    if (minus)
-        dec = dec.slice(1);
-    // Work 6 decimal digits at a time, acting like we're converting base 1e6
-    // digits to binary. This is safe to do with floating point math because
-    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
-    const base = 1e6;
-    let lowBits = 0;
-    let highBits = 0;
-    function add1e6digit(begin, end) {
-        // Note: Number('') is 0.
-        const digit1e6 = Number(dec.slice(begin, end));
-        highBits *= base;
-        lowBits = lowBits * base + digit1e6;
-        // Carry bits from lowBits to
-        if (lowBits >= TWO_PWR_32_DBL$1) {
-            highBits = highBits + ((lowBits / TWO_PWR_32_DBL$1) | 0);
-            lowBits = lowBits % TWO_PWR_32_DBL$1;
-        }
-    }
-    add1e6digit(-24, -18);
-    add1e6digit(-18, -12);
-    add1e6digit(-12, -6);
-    add1e6digit(-6);
-    return [minus, lowBits, highBits];
-}
-/**
- * Format 64 bit integer value (as two JS numbers) to decimal string.
- *
- * Copyright 2008 Google Inc.
- */
-function int64toString(bitsLow, bitsHigh) {
-    // Skip the expensive conversion if the number is small enough to use the
-    // built-in conversions.
-    if (bitsHigh <= 0x1FFFFF) {
-        return '' + (TWO_PWR_32_DBL$1 * bitsHigh + (bitsLow >>> 0));
-    }
-    // What this code is doing is essentially converting the input number from
-    // base-2 to base-1e7, which allows us to represent the 64-bit range with
-    // only 3 (very large) digits. Those digits are then trivial to convert to
-    // a base-10 string.
-    // The magic numbers used here are -
-    // 2^24 = 16777216 = (1,6777216) in base-1e7.
-    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
-    // Split 32:32 representation into 16:24:24 representation so our
-    // intermediate digits don't overflow.
-    let low = bitsLow & 0xFFFFFF;
-    let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xFFFFFF;
-    let high = (bitsHigh >> 16) & 0xFFFF;
-    // Assemble our three base-1e7 digits, ignoring carries. The maximum
-    // value in a digit at this step is representable as a 48-bit integer, which
-    // can be stored in a 64-bit floating point number.
-    let digitA = low + (mid * 6777216) + (high * 6710656);
-    let digitB = mid + (high * 8147497);
-    let digitC = (high * 2);
-    // Apply carries from A to B and from B to C.
-    let base = 10000000;
-    if (digitA >= base) {
-        digitB += Math.floor(digitA / base);
-        digitA %= base;
-    }
-    if (digitB >= base) {
-        digitC += Math.floor(digitB / base);
-        digitB %= base;
-    }
-    // Convert base-1e7 digits to base-10, with optional leading zeroes.
-    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);
-}
-/**
- * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
- *
- * Copyright 2008 Google Inc.  All rights reserved.
- *
- * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
- */
-function varint32write(value, bytes) {
-    if (value >= 0) {
-        // write value as varint 32
-        while (value > 0x7f) {
-            bytes.push((value & 0x7f) | 0x80);
-            value = value >>> 7;
-        }
-        bytes.push(value);
-    }
-    else {
-        for (let i = 0; i < 9; i++) {
-            bytes.push(value & 127 | 128);
-            value = value >> 7;
-        }
-        bytes.push(1);
-    }
-}
-/**
- * Read an unsigned 32 bit varint.
- *
- * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
- */
-function varint32read() {
-    let b = this.buf[this.pos++];
-    let result = b & 0x7F;
-    if ((b & 0x80) == 0) {
-        this.assertBounds();
-        return result;
-    }
-    b = this.buf[this.pos++];
-    result |= (b & 0x7F) << 7;
-    if ((b & 0x80) == 0) {
-        this.assertBounds();
-        return result;
-    }
-    b = this.buf[this.pos++];
-    result |= (b & 0x7F) << 14;
-    if ((b & 0x80) == 0) {
-        this.assertBounds();
-        return result;
-    }
-    b = this.buf[this.pos++];
-    result |= (b & 0x7F) << 21;
-    if ((b & 0x80) == 0) {
-        this.assertBounds();
-        return result;
-    }
-    // Extract only last 4 bits
-    b = this.buf[this.pos++];
-    result |= (b & 0x0F) << 28;
-    for (let readBytes = 5; ((b & 0x80) !== 0) && readBytes < 10; readBytes++)
-        b = this.buf[this.pos++];
-    if ((b & 0x80) != 0)
-        throw new Error('invalid varint');
-    this.assertBounds();
-    // Result can have 32 bits, convert it to unsigned
-    return result >>> 0;
-}
-
-function detectBi() {
-    const dv = new DataView(new ArrayBuffer(8));
-    const ok = globalThis.BigInt !== undefined
-        && typeof dv.getBigInt64 === "function"
-        && typeof dv.getBigUint64 === "function"
-        && typeof dv.setBigInt64 === "function"
-        && typeof dv.setBigUint64 === "function";
-    return ok ? {
-        MIN: BigInt("-9223372036854775808"),
-        MAX: BigInt("9223372036854775807"),
-        UMIN: BigInt("0"),
-        UMAX: BigInt("18446744073709551615"),
-        C: BigInt,
-        V: dv,
-    } : undefined;
-}
-const BI = 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");
-}
-// used to validate from(string) input (when bigint is unavailable)
-const RE_DECIMAL_STR = /^-?[0-9]+$/;
-// constants for binary math
-const TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
-// base class for PbLong and PbULong provides shared code
-class SharedPbLong {
-    /**
-     * 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_DBL + (this.lo >>> 0);
-        if (!Number.isSafeInteger(result))
-            throw new Error("cannot convert to safe number");
-        return result;
-    }
-}
-/**
- * 64-bit unsigned integer as two 32-bit values.
- * Converts between `string`, `number` and `bigint` representations.
- */
-class PbULong extends SharedPbLong {
-    /**
-     * Create instance from a `string`, `number` or `bigint`.
-     */
-    static from(value) {
-        if (BI)
-            // noinspection FallThroughInSwitchStatementJS
-            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');
-                    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_DBL);
-            }
-        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);
-    }
-}
-/**
- * ulong 0 singleton.
- */
-PbULong.ZERO = new PbULong(0, 0);
-/**
- * 64-bit signed integer as two 32-bit values.
- * Converts between `string`, `number` and `bigint` representations.
- */
-class PbLong extends SharedPbLong {
-    /**
-     * Create instance from a `string`, `number` or `bigint`.
-     */
-    static from(value) {
-        if (BI)
-            // noinspection FallThroughInSwitchStatementJS
-            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('ulong too small');
-                    if (value > BI.MAX)
-                        throw new Error('ulong 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);
-                    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_DBL)
-                        : new PbLong(-value, -value / TWO_PWR_32_DBL).negate();
-            }
-        throw new Error('unknown value ' + typeof value);
-    }
-    /**
-     * Do we have a minus sign?
-     */
-    isNegative() {
-        return (this.hi & 0x80000000) !== 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);
-    }
-}
-/**
- * long 0 singleton.
- */
-PbLong.ZERO = new PbLong(0, 0);
-
-const defaultsRead$1 = {
-    readUnknownField: true,
-    readerFactory: bytes => new BinaryReader(bytes),
-};
-/**
- * Make options for reading binary data form partial options.
- */
-function binaryReadOptions(options) {
-    return options ? Object.assign(Object.assign({}, defaultsRead$1), options) : defaultsRead$1;
-}
-class BinaryReader {
-    constructor(buf, textDecoder) {
-        this.varint64 = varint64read; // dirty cast for `this`
-        /**
-         * Read a `uint32` field, an unsigned 32 bit varint.
-         */
-        this.uint32 = varint32read; // dirty cast for `this` and access to protected `buf`
-        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;
-        // noinspection FallThroughInSwitchStatementJS
-        switch (wireType) {
-            case WireType.Varint:
-                while (this.buf[this.pos++] & 0x80) {
-                    // ignore
-                }
-                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:
-                // From descriptor.proto: Group type is deprecated, not supported in proto3.
-                // But we must still be able to parse and treat as unknown.
-                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();
-        // decode zigzag
-        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();
-        // decode zig zag
-        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());
-    }
-}
-
-/**
- * assert that condition is true or throw error (with message)
- */
-function assert(condition, msg) {
-    if (!condition) {
-        throw new Error(msg);
-    }
-}
-const FLOAT32_MAX = 3.4028234663852886e+38, FLOAT32_MIN = -3.4028234663852886e+38, UINT32_MAX = 0xFFFFFFFF, INT32_MAX = 0X7FFFFFFF, INT32_MIN = -0X80000000;
-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);
-}
-
-const defaultsWrite$1 = {
-    writeUnknownFields: true,
-    writerFactory: () => new BinaryWriter(),
-};
-/**
- * Make options for writing binary data form partial options.
- */
-function binaryWriteOptions(options) {
-    return options ? Object.assign(Object.assign({}, defaultsWrite$1), options) : defaultsWrite$1;
-}
-class BinaryWriter {
-    constructor(textEncoder) {
-        /**
-         * Previous fork states.
-         */
-        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)); // flush the buffer
-        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() {
-        // get chunk of fork
-        let chunk = this.finish();
-        // restore previous state
-        let prev = this.stack.pop();
-        if (!prev)
-            throw new Error('invalid state, fork stack empty');
-        this.chunks = prev.chunks;
-        this.buf = prev.buf;
-        // write length of chunk as varint
-        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);
-        // write value as varint 32, inlined for speed
-        while (value > 0x7f) {
-            this.buf.push((value & 0x7f) | 0x80);
-            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); // write length of chunk as varint
-        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); // write length of chunk as varint
-        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);
-        // zigzag encode
-        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), 
-        // zigzag encode
-        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;
-    }
-}
-
-const defaultsWrite = {
-    emitDefaultValues: false,
-    enumAsInteger: false,
-    useProtoFieldName: false,
-    prettySpaces: 0,
-}, defaultsRead = {
-    ignoreUnknownFields: false,
-};
-/**
- * Make options for reading JSON data from partial options.
- */
-function jsonReadOptions(options) {
-    return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead;
-}
-/**
- * Make options for writing JSON data from partial options.
- */
-function jsonWriteOptions(options) {
-    return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite;
-}
-
-/**
- * The symbol used as a key on message objects to store the message type.
- *
- * Note that this is an experimental feature - it is here to stay, but
- * implementation details may change without notice.
- */
-const MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type");
-
-/**
- * Converts snake_case to lowerCamelCase.
- *
- * Should behave like protoc:
- * https://github.com/protocolbuffers/protobuf/blob/e8ae137c96444ea313485ed1118c5e43b2099cf1/src/google/protobuf/compiler/java/java_helpers.cc#L118
- */
-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('');
-}
-
-/**
- * Scalar value types. This is a subset of field types declared by protobuf
- * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
- * are omitted, but the numerical values are identical.
- */
-var ScalarType;
-(function (ScalarType) {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
-    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT64"] = 3] = "INT64";
-    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT32"] = 5] = "INT32";
-    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
-    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
-    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
-    ScalarType[ScalarType["STRING"] = 9] = "STRING";
-    // Tag-delimited aggregate.
-    // Group type is deprecated and not supported in proto3. However, Proto3
-    // implementations should still be able to parse the group wire format and
-    // treat group fields as unknown fields.
-    // TYPE_GROUP = 10,
-    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
-    // New in version 2.
-    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
-    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
-    // TYPE_ENUM = 14,
-    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
-    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
-    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
-    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
-})(ScalarType || (ScalarType = {}));
-/**
- * JavaScript representation of 64 bit integral types. Equivalent to the
- * field option "jstype".
- *
- * By default, protobuf-ts represents 64 bit types as `bigint`.
- *
- * You can change the default behaviour by enabling the plugin parameter
- * `long_type_string`, which will represent 64 bit types as `string`.
- *
- * Alternatively, you can change the behaviour for individual fields
- * with the field option "jstype":
- *
- * ```protobuf
- * uint64 my_field = 1 [jstype = JS_STRING];
- * uint64 other_field = 2 [jstype = JS_NUMBER];
- * ```
- */
-var LongType;
-(function (LongType) {
-    /**
-     * Use JavaScript `bigint`.
-     *
-     * Field option `[jstype = JS_NORMAL]`.
-     */
-    LongType[LongType["BIGINT"] = 0] = "BIGINT";
-    /**
-     * Use JavaScript `string`.
-     *
-     * Field option `[jstype = JS_STRING]`.
-     */
-    LongType[LongType["STRING"] = 1] = "STRING";
-    /**
-     * Use JavaScript `number`.
-     *
-     * Large values will loose precision.
-     *
-     * Field option `[jstype = JS_NUMBER]`.
-     */
-    LongType[LongType["NUMBER"] = 2] = "NUMBER";
-})(LongType || (LongType = {}));
-/**
- * Protobuf 2.1.0 introduced packed repeated fields.
- * Setting the field option `[packed = true]` enables packing.
- *
- * In proto3, all repeated fields are packed by default.
- * Setting the field option `[packed = false]` disables packing.
- *
- * Packed repeated fields are encoded with a single tag,
- * then a length-delimiter, then the element values.
- *
- * Unpacked repeated fields are encoded with a tag and
- * value for each element.
- *
- * `bytes` and `string` cannot be packed.
- */
-var RepeatType;
-(function (RepeatType) {
-    /**
-     * The field is not repeated.
-     */
-    RepeatType[RepeatType["NO"] = 0] = "NO";
-    /**
-     * The field is repeated and should be packed.
-     * Invalid for `bytes` and `string`, they cannot be packed.
-     */
-    RepeatType[RepeatType["PACKED"] = 1] = "PACKED";
-    /**
-     * The field is repeated but should not be packed.
-     * The only valid repeat type for repeated `bytes` and `string`.
-     */
-    RepeatType[RepeatType["UNPACKED"] = 2] = "UNPACKED";
-})(RepeatType || (RepeatType = {}));
-/**
- * Turns PartialFieldInfo into FieldInfo.
- */
-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;
-}
-
-/**
- * Is the given value a valid oneof group?
- *
- * We represent protobuf `oneof` as algebraic data types (ADT) in generated
- * code. But when working with messages of unknown type, the ADT does not
- * help us.
- *
- * This type guard checks if the given object adheres to the ADT rules, which
- * are as follows:
- *
- * 1) Must be an object.
- *
- * 2) Must have a "oneofKind" discriminator property.
- *
- * 3) If "oneofKind" is `undefined`, no member field is selected. The object
- * must not have any other properties.
- *
- * 4) If "oneofKind" is a `string`, the member field with this name is
- * selected.
- *
- * 5) If a member field is selected, the object must have a second property
- * with this name. The property must not be `undefined`.
- *
- * 6) No extra properties are allowed. The object has either one property
- * (no selection) or two properties (selection).
- *
- */
-function isOneofGroup(any) {
-    if (typeof any != 'object' || any === null || !any.hasOwnProperty('oneofKind')) {
-        return false;
-    }
-    switch (typeof any.oneofKind) {
-        case "string":
-            if (any[any.oneofKind] === undefined)
-                return false;
-            return Object.keys(any).length == 2;
-        case "undefined":
-            return Object.keys(any).length == 1;
-        default:
-            return false;
-    }
-}
-
-// noinspection JSMethodCanBeStatic
-class ReflectionTypeCheck {
-    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 === undefined || typeof message != 'object')
-            return false;
-        this.prepare();
-        let keys = Object.keys(message), data = this.data;
-        // if a required field is missing in arg, this cannot be a T
-        if (keys.length < data.req.length || data.req.some(n => !keys.includes(n)))
-            return false;
-        if (!allowExcessProperties) {
-            // if the arg contains a key we dont know, this is not a literal T
-            if (keys.some(k => !data.known.includes(k)))
-                return false;
-        }
-        // "With a depth of 0, only the presence and absence of fields is checked."
-        // "With a depth of 1 or more, the field types are checked."
-        if (depth < 1) {
-            return true;
-        }
-        // check oneof group
-        for (const name of data.oneofs) {
-            const group = message[name];
-            if (!isOneofGroup(group))
-                return false;
-            if (group.oneofKind === undefined)
-                continue;
-            const field = this.fields.find(f => f.localName === group.oneofKind);
-            if (!field)
-                return false; // we found no field, but have a kind, something is wrong
-            if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth))
-                return false;
-        }
-        // check types
-        for (const field of this.fields) {
-            if (field.oneof !== undefined)
-                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 === undefined)
-                    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 === undefined)
-                    return field.opt;
-                if (repeated)
-                    return this.scalars(arg, ScalarType.INT32, depth);
-                return this.scalar(arg, ScalarType.INT32);
-            case "message":
-                if (arg === undefined)
-                    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:
-                // case ScalarType.UINT32:
-                // case ScalarType.FIXED32:
-                // case ScalarType.INT32:
-                // case ScalarType.SINT32:
-                // case ScalarType.SFIXED32:
-                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);
-        }
-    }
-}
-
-/**
- * Utility method to convert a PbLong or PbUlong to a JavaScript
- * representation during runtime.
- *
- * Works with generated field information, `undefined` is equivalent
- * to `STRING`.
- */
-function reflectionLongConvert(long, type) {
-    switch (type) {
-        case LongType.BIGINT:
-            return long.toBigInt();
-        case LongType.NUMBER:
-            return long.toNumber();
-        default:
-            // case undefined:
-            // case LongType.STRING:
-            return long.toString();
-    }
-}
-
-/**
- * Reads proto3 messages in canonical JSON format using reflection information.
- *
- * https://developers.google.com/protocol-buffers/docs/proto3#json
- */
-class ReflectionJsonReader {
-    constructor(info) {
-        this.info = info;
-    }
-    prepare() {
-        var _a;
-        if (this.fMap === undefined) {
-            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;
-            // handle oneof ADT
-            let target; // this will be the target for the field value, whether it is member of a oneof or not
-            if (field.oneof) {
-                // since json objects are unordered by specification, it is not possible to take the last of multiple oneofs
-                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;
-            }
-            // we have handled oneof above. we just have read the value into `target`.
-            if (field.kind == 'map') {
-                if (jsonValue === null) {
-                    continue;
-                }
-                // check input
-                this.assert(isJsonObject(jsonValue), field.name, jsonValue);
-                // our target to put map entries into
-                const fieldObj = target[localName];
-                // read entries
-                for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) {
-                    this.assert(jsonObjValue !== null, field.name + " map value", null);
-                    // read value
-                    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 !== undefined, field.name + " map value", jsonObjValue);
-                    // read key
-                    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;
-                // check input
-                this.assert(Array.isArray(jsonValue), field.name, jsonValue);
-                // our target to put array entries into
-                const fieldArr = target[localName];
-                // read array entries
-                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 !== undefined, 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 === undefined, field.name + " (oneof member)", null);
-                            continue;
-                        }
-                        target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]);
-                        break;
-                    case "enum":
-                        let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields);
-                        if (val === false)
-                            continue;
-                        target[localName] = val;
-                        break;
-                    case "scalar":
-                        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`.
-     */
-    enum(type, json, fieldName, ignoreUnknownFields) {
-        if (type[0] == 'google.protobuf.NullValue')
-            assert(json === null, `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`);
-        if (json === null)
-            // we require 0 to be default value for all enums
-            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])
-                    // lookup without the shared prefix
-                    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)) {
-                        // infinity and -infinity are handled by string representation above, so this is an error
-                        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 === undefined)
-                        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 (e) {
-                        e = "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);
-    }
-}
-
-/**
- * Writes proto3 messages in canonical JSON format using reflection
- * information.
- *
- * https://developers.google.com/protocol-buffers/docs/proto3#json
- */
-class ReflectionJsonWriter {
-    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) {
-            // field is not part of a oneof, simply write as is
-            if (!field.oneof) {
-                let jsonValue = this.field(field, source[field.localName], options);
-                if (jsonValue !== undefined)
-                    json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
-                continue;
-            }
-            // field is part of a oneof
-            const group = source[field.oneof];
-            if (group.oneofKind !== field.localName)
-                continue; // not selected, skip
-            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 !== undefined);
-            json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
-        }
-        return json;
-    }
-    field(field, value, options) {
-        let jsonValue = undefined;
-        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 !== undefined);
-                        jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-                    }
-                    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 !== undefined);
-                        jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-                    }
-                    break;
-                case "enum":
-                    const enumInfo = field.V.T();
-                    for (const [entryKey, entryValue] of Object.entries(value)) {
-                        assert(entryValue === undefined || typeof entryValue == 'number');
-                        const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger);
-                        assert(val !== undefined);
-                        jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-                    }
-                    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 !== undefined);
-                        jsonArr.push(val);
-                    }
-                    break;
-                case "enum":
-                    const enumInfo = field.T();
-                    for (let i = 0; i < value.length; i++) {
-                        assert(value[i] === undefined || typeof value[i] == 'number');
-                        const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger);
-                        assert(val !== undefined);
-                        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 !== undefined);
-                        jsonArr.push(val);
-                    }
-                    break;
-            }
-            // add converted array to json output
-            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` for google.protobuf.NullValue.
-     */
-    enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) {
-        if (type[0] == 'google.protobuf.NullValue')
-            return null;
-        if (value === undefined) {
-            assert(optional);
-            return undefined;
-        }
-        if (value === 0 && !emitDefaultValues && !optional)
-            // we require 0 to be default value for all enums
-            return undefined;
-        assert(typeof value == 'number');
-        assert(Number.isInteger(value));
-        if (enumAsInteger || !type[1].hasOwnProperty(value))
-            // if we don't now the enum value, just return the number
-            return value;
-        if (type[2])
-            // restore the dropped prefix
-            return type[2] + type[1][value];
-        return type[1][value];
-    }
-    message(type, value, fieldName, options) {
-        if (value === undefined)
-            return options.emitDefaultValues ? null : undefined;
-        return type.internalJsonWrite(value, options);
-    }
-    scalar(type, value, fieldName, optional, emitDefaultValues) {
-        if (value === undefined) {
-            assert(optional);
-            return undefined;
-        }
-        const ed = emitDefaultValues || optional;
-        // noinspection FallThroughInSwitchStatementJS
-        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 : undefined;
-                assertInt32(value);
-                return value;
-            case ScalarType.FIXED32:
-            case ScalarType.UINT32:
-                if (value === 0)
-                    return ed ? 0 : undefined;
-                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 : undefined;
-                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 ? '' : undefined;
-                assert(typeof value == 'string');
-                return value;
-            // bool:
-            case ScalarType.BOOL:
-                if (value === false)
-                    return ed ? false : undefined;
-                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 undefined;
-                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 undefined;
-                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 ? "" : undefined;
-                return base64encode(value);
-        }
-    }
-}
-
-/**
- * Creates the default value for a scalar type.
- */
-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.0;
-        case ScalarType.BYTES:
-            return new Uint8Array(0);
-        case ScalarType.STRING:
-            return "";
-        default:
-            // case ScalarType.INT32:
-            // case ScalarType.UINT32:
-            // case ScalarType.SINT32:
-            // case ScalarType.FIXED32:
-            // case ScalarType.SFIXED32:
-            return 0;
-    }
-}
-
-/**
- * Reads proto3 messages in binary format using reflection information.
- *
- * https://developers.google.com/protocol-buffers/docs/encoding
- */
-class ReflectionBinaryReader {
-    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 === undefined ? reader.len : reader.pos + length;
-        while (reader.pos < end) {
-            // read the tag and find the field
-            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;
-            }
-            // target object for the field we are reading
-            let target = message, repeated = field.repeat, localName = field.localName;
-            // if field is member of oneof ADT, use ADT as target
-            if (field.oneof) {
-                target = target[field.oneof];
-                // if other oneof member selected, set new ADT
-                if (target.oneofKind !== localName)
-                    target = message[field.oneof] = {
-                        oneofKind: localName
-                    };
-            }
-            // we have handled oneof above, we just have read the value into `target[localName]`
-            switch (field.kind) {
-                case "scalar":
-                case "enum":
-                    let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
-                    let L = field.kind == "scalar" ? field.L : undefined;
-                    if (repeated) {
-                        let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
-                        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]; // safe to assume presence of array, oneof cannot contain repeated values
-                        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);
-                    // safe to assume presence of map object, oneof cannot contain repeated values
-                    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 = undefined; // javascript only allows number or string for object properties
-        let val = undefined;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case 1:
-                    if (field.K == ScalarType.BOOL)
-                        key = reader.bool().toString();
-                    else
-                        // long types are read as string, number types are okay as number
-                        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 === undefined) {
-            let keyRaw = reflectionScalarDefault(field.K);
-            key = field.K == ScalarType.BOOL ? keyRaw.toString() : keyRaw;
-        }
-        if (val === undefined)
-            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);
-        }
-    }
-}
-
-/**
- * Writes proto3 messages in binary format using reflection information.
- *
- * https://developers.google.com/protocol-buffers/docs/encoding
- */
-class ReflectionBinaryWriter {
-    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, // this will be our field value, whether it is member of a oneof or not
-            emitDefault, // whether we emit the default value (only true for oneof members)
-            repeated = field.repeat, localName = field.localName;
-            // handle oneof ADT
-            if (field.oneof) {
-                const group = message[field.oneof];
-                if (group.oneofKind !== localName)
-                    continue; // if field is not selected, skip
-                value = group[localName];
-                emitDefault = true;
-            }
-            else {
-                value = message[localName];
-                emitDefault = false;
-            }
-            // we have handled oneof above. we just have to honor `emitDefault`.
-            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 === undefined)
-                        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();
-        // javascript only allows number or string for object properties
-        // we convert from our representation to the protobuf type
-        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;
-        }
-        // write key, expecting key field number = 1
-        this.scalar(writer, field.K, 1, keyValue, true);
-        // write value, expecting value field number = 2
-        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 === undefined)
-            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);
-        // write tag
-        writer.tag(fieldNo, WireType.LengthDelimited);
-        // begin length-delimited
-        writer.fork();
-        // write values without tags
-        let [, method,] = this.scalarInfo(type);
-        for (let i = 0; i < value.length; i++)
-            writer[method](value[i]);
-        // end length delimited
-        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 === undefined;
-        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];
-    }
-}
-
-/**
- * Creates an instance of the generic message, using the field
- * information.
- */
-function reflectionCreate(type) {
-    const msg = {};
-    Object.defineProperty(msg, MESSAGE_TYPE, { enumerable: false, value: type });
-    for (let field of type.fields) {
-        let name = field.localName;
-        if (field.opt)
-            continue;
-        if (field.oneof)
-            msg[field.oneof] = { oneofKind: undefined };
-        else if (field.repeat)
-            msg[name] = [];
-        else
-            switch (field.kind) {
-                case "scalar":
-                    msg[name] = reflectionScalarDefault(field.T, field.L);
-                    break;
-                case "enum":
-                    // we require 0 to be default value for all enums
-                    msg[name] = 0;
-                    break;
-                case "map":
-                    msg[name] = {};
-                    break;
-            }
-    }
-    return msg;
-}
-
-/**
- * Copy partial data into the target message.
- *
- * If a singular scalar or enum field is present in the source, it
- * replaces the field in the target.
- *
- * If a singular message field is present in the source, it is merged
- * with the target field by calling mergePartial() of the responsible
- * message type.
- *
- * If a repeated field is present in the source, its values replace
- * all values in the target array, removing extraneous values.
- * Repeated message fields are copied, not merged.
- *
- * If a map field is present in the source, entries are added to the
- * target map, replacing entries with the same key. Entries that only
- * exist in the target remain. Entries with message values are copied,
- * not merged.
- *
- * Note that this function differs from protobuf merge semantics,
- * which appends repeated fields.
- */
-function reflectionMergePartial(info, target, source) {
-    let fieldValue, // the field value we are working with
-    input = source, output; // where we want our field value to go
-    for (let field of info.fields) {
-        let name = field.localName;
-        if (field.oneof) {
-            const group = input[field.oneof]; // this is the oneof`s group in the source
-            if ((group === null || group === void 0 ? void 0 : group.oneofKind) == undefined) { // the user is free to omit
-                continue; // we skip this field, and all other members too
-            }
-            fieldValue = group[name]; // our value comes from the the oneof group of the source
-            output = target[field.oneof]; // and our output is the oneof group of the target
-            output.oneofKind = group.oneofKind; // always update discriminator
-            if (fieldValue == undefined) {
-                delete output[name]; // remove any existing value
-                continue; // skip further work on field
-            }
-        }
-        else {
-            fieldValue = input[name]; // we are using the source directly
-            output = target; // we want our field value to go directly into the target
-            if (fieldValue == undefined) {
-                continue; // skip further work on field, existing value is used as is
-            }
-        }
-        if (field.repeat)
-            output[name].length = fieldValue.length; // resize target array to match source array
-        // now we just work with `fieldValue` and `output` to merge the value
-        switch (field.kind) {
-            case "scalar":
-            case "enum":
-                if (field.repeat)
-                    for (let i = 0; i < fieldValue.length; i++)
-                        output[name][i] = fieldValue[i]; // not a reference type
-                else
-                    output[name] = fieldValue; // not a reference type
-                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] === undefined)
-                    output[name] = T.create(fieldValue); // nothing to merge with
-                else
-                    T.mergePartial(output[name], fieldValue);
-                break;
-            case "map":
-                // Map and repeated fields are simply overwritten, not appended or merged
-                switch (field.V.kind) {
-                    case "scalar":
-                    case "enum":
-                        Object.assign(output[name], fieldValue); // elements are not reference types
-                        break;
-                    case "message":
-                        let T = field.V.T();
-                        for (let k of Object.keys(fieldValue))
-                            output[name][k] = T.create(fieldValue[k]);
-                        break;
-                }
-                break;
-        }
-    }
-}
-
-/**
- * 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`.
- */
-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;
-}
-const 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;
-}
-
-/**
- * This standard message type provides reflection-based
- * operations to work with a message.
- */
-class MessageType {
-    constructor(name, fields, options) {
-        this.defaultCheckDepth = 16;
-        this.typeName = name;
-        this.fields = fields.map(normalizeFieldInfo);
-        this.options = options !== null && options !== void 0 ? options : {};
-        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 !== undefined) {
-            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;
-    }
-}
-
 /**
  * `NullValue` is a singleton enumeration to represent the null value for the
  * `Value` type union.
@@ -3020,7 +121,7 @@ var NullValue;
     NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
 })(NullValue || (NullValue = {}));
 // @generated message type with reflection information, may provide speed optimized methods
-class Struct$Type extends MessageType {
+class Struct$Type extends runtime.MessageType {
     constructor() {
         super("google.protobuf.Struct", [
             { no: 1, name: "fields", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } }
@@ -3040,8 +141,8 @@ class Struct$Type extends MessageType {
      * 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 (!runtime.isJsonObject(json))
+            throw new globalThis.Error("Unable to parse message " + this.typeName + " from JSON " + runtime.typeofJsonValue(json) + ".");
         if (!target)
             target = this.create();
         for (let [k, v] of globalThis.Object.entries(json)) {
@@ -3051,9 +152,9 @@ class Struct$Type extends MessageType {
     }
     create(value) {
         const message = { fields: {} };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3070,7 +171,7 @@ class Struct$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3094,14 +195,14 @@ class Struct$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* map<string, google.protobuf.Value> fields = 1; */
         for (let k of Object.keys(message.fields)) {
-            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
-            writer.tag(2, WireType.LengthDelimited).fork();
+            writer.tag(1, runtime.WireType.LengthDelimited).fork().tag(1, runtime.WireType.LengthDelimited).string(k);
+            writer.tag(2, runtime.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);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3110,7 +211,7 @@ class Struct$Type extends MessageType {
  */
 const Struct = new Struct$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class Value$Type extends MessageType {
+class Value$Type extends runtime.MessageType {
     constructor() {
         super("google.protobuf.Value", [
             { no: 1, name: "null_value", kind: "enum", oneof: "kind", T: () => ["google.protobuf.NullValue", NullValue] },
@@ -3173,15 +274,15 @@ class Value$Type extends MessageType {
                     target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
                 }
                 break;
-            default: throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+            default: throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + runtime.typeofJsonValue(json));
         }
         return target;
     }
     create(value) {
         const message = { kind: { oneofKind: undefined } };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3231,7 +332,7 @@ class Value$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3239,25 +340,25 @@ class Value$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* google.protobuf.NullValue null_value = 1; */
         if (message.kind.oneofKind === "nullValue")
-            writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
+            writer.tag(1, runtime.WireType.Varint).int32(message.kind.nullValue);
         /* double number_value = 2; */
         if (message.kind.oneofKind === "numberValue")
-            writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
+            writer.tag(2, runtime.WireType.Bit64).double(message.kind.numberValue);
         /* string string_value = 3; */
         if (message.kind.oneofKind === "stringValue")
-            writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.kind.stringValue);
         /* bool bool_value = 4; */
         if (message.kind.oneofKind === "boolValue")
-            writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
+            writer.tag(4, runtime.WireType.Varint).bool(message.kind.boolValue);
         /* google.protobuf.Struct struct_value = 5; */
         if (message.kind.oneofKind === "structValue")
-            Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, runtime.WireType.LengthDelimited).fork(), options).join();
         /* google.protobuf.ListValue list_value = 6; */
         if (message.kind.oneofKind === "listValue")
-            ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+            ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3266,7 +367,7 @@ class Value$Type extends MessageType {
  */
 const Value = new Value$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ListValue$Type extends MessageType {
+class ListValue$Type extends runtime.MessageType {
     constructor() {
         super("google.protobuf.ListValue", [
             { no: 1, name: "values", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Value }
@@ -3283,7 +384,7 @@ class ListValue$Type extends MessageType {
      */
     internalJsonRead(json, options, target) {
         if (!globalThis.Array.isArray(json))
-            throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+            throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + runtime.typeofJsonValue(json));
         if (!target)
             target = this.create();
         let values = json.map(v => Value.fromJson(v));
@@ -3292,9 +393,9 @@ class ListValue$Type extends MessageType {
     }
     create(value) {
         const message = { values: [] };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3311,7 +412,7 @@ class ListValue$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3319,10 +420,10 @@ class ListValue$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* repeated google.protobuf.Value values = 1; */
         for (let i = 0; i < message.values.length; i++)
-            Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+            Value.internalBinaryWrite(message.values[i], writer.tag(1, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3333,7 +434,7 @@ const ListValue = new ListValue$Type();
 
 // @generated by protobuf-ts 2.2.2 with parameter long_type_string,generate_dependencies
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveAllRequest$Type extends MessageType {
+class ResolveAllRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveAllRequest", [
             { no: 1, name: "context", kind: "message", T: () => Struct }
@@ -3341,9 +442,9 @@ class ResolveAllRequest$Type extends MessageType {
     }
     create(value) {
         const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3360,7 +461,7 @@ class ResolveAllRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3368,10 +469,10 @@ class ResolveAllRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* google.protobuf.Struct context = 1; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(1, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3380,7 +481,7 @@ class ResolveAllRequest$Type extends MessageType {
  */
 const ResolveAllRequest = new ResolveAllRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveAllResponse$Type extends MessageType {
+class ResolveAllResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveAllResponse", [
             { no: 1, name: "flags", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => AnyFlag } }
@@ -3388,9 +489,9 @@ class ResolveAllResponse$Type extends MessageType {
     }
     create(value) {
         const message = { flags: {} };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3407,7 +508,7 @@ class ResolveAllResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3431,14 +532,14 @@ class ResolveAllResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* map<string, schema.v1.AnyFlag> flags = 1; */
         for (let k of Object.keys(message.flags)) {
-            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
-            writer.tag(2, WireType.LengthDelimited).fork();
+            writer.tag(1, runtime.WireType.LengthDelimited).fork().tag(1, runtime.WireType.LengthDelimited).string(k);
+            writer.tag(2, runtime.WireType.LengthDelimited).fork();
             AnyFlag.internalBinaryWrite(message.flags[k], writer, options);
             writer.join().join();
         }
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3447,7 +548,7 @@ class ResolveAllResponse$Type extends MessageType {
  */
 const ResolveAllResponse = new ResolveAllResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class AnyFlag$Type extends MessageType {
+class AnyFlag$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.AnyFlag", [
             { no: 1, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3460,9 +561,9 @@ class AnyFlag$Type extends MessageType {
     }
     create(value) {
         const message = { reason: "", variant: "", value: { oneofKind: undefined } };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3506,7 +607,7 @@ class AnyFlag$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3514,25 +615,25 @@ class AnyFlag$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string reason = 1; */
         if (message.reason !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.reason);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 2; */
         if (message.variant !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.variant);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.variant);
         /* bool bool_value = 3; */
         if (message.value.oneofKind === "boolValue")
-            writer.tag(3, WireType.Varint).bool(message.value.boolValue);
+            writer.tag(3, runtime.WireType.Varint).bool(message.value.boolValue);
         /* string string_value = 4; */
         if (message.value.oneofKind === "stringValue")
-            writer.tag(4, WireType.LengthDelimited).string(message.value.stringValue);
+            writer.tag(4, runtime.WireType.LengthDelimited).string(message.value.stringValue);
         /* double double_value = 5; */
         if (message.value.oneofKind === "doubleValue")
-            writer.tag(5, WireType.Bit64).double(message.value.doubleValue);
+            writer.tag(5, runtime.WireType.Bit64).double(message.value.doubleValue);
         /* google.protobuf.Struct object_value = 6; */
         if (message.value.oneofKind === "objectValue")
-            Struct.internalBinaryWrite(message.value.objectValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.value.objectValue, writer.tag(6, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3541,7 +642,7 @@ class AnyFlag$Type extends MessageType {
  */
 const AnyFlag = new AnyFlag$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveBooleanRequest$Type extends MessageType {
+class ResolveBooleanRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveBooleanRequest", [
             { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3550,9 +651,9 @@ class ResolveBooleanRequest$Type extends MessageType {
     }
     create(value) {
         const message = { flagKey: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3572,7 +673,7 @@ class ResolveBooleanRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3580,13 +681,13 @@ class ResolveBooleanRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string flag_key = 1; */
         if (message.flagKey !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.flagKey);
         /* google.protobuf.Struct context = 2; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3595,7 +696,7 @@ class ResolveBooleanRequest$Type extends MessageType {
  */
 const ResolveBooleanRequest = new ResolveBooleanRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveBooleanResponse$Type extends MessageType {
+class ResolveBooleanResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveBooleanResponse", [
             { no: 1, name: "value", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
@@ -3605,9 +706,9 @@ class ResolveBooleanResponse$Type extends MessageType {
     }
     create(value) {
         const message = { value: false, reason: "", variant: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3630,7 +731,7 @@ class ResolveBooleanResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3638,16 +739,16 @@ class ResolveBooleanResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* bool value = 1; */
         if (message.value !== false)
-            writer.tag(1, WireType.Varint).bool(message.value);
+            writer.tag(1, runtime.WireType.Varint).bool(message.value);
         /* string reason = 2; */
         if (message.reason !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 3; */
         if (message.variant !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.variant);
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3656,7 +757,7 @@ class ResolveBooleanResponse$Type extends MessageType {
  */
 const ResolveBooleanResponse = new ResolveBooleanResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveStringRequest$Type extends MessageType {
+class ResolveStringRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveStringRequest", [
             { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3665,9 +766,9 @@ class ResolveStringRequest$Type extends MessageType {
     }
     create(value) {
         const message = { flagKey: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3687,7 +788,7 @@ class ResolveStringRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3695,13 +796,13 @@ class ResolveStringRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string flag_key = 1; */
         if (message.flagKey !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.flagKey);
         /* google.protobuf.Struct context = 2; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3710,7 +811,7 @@ class ResolveStringRequest$Type extends MessageType {
  */
 const ResolveStringRequest = new ResolveStringRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveStringResponse$Type extends MessageType {
+class ResolveStringResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveStringResponse", [
             { no: 1, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3720,9 +821,9 @@ class ResolveStringResponse$Type extends MessageType {
     }
     create(value) {
         const message = { value: "", reason: "", variant: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3745,7 +846,7 @@ class ResolveStringResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3753,16 +854,16 @@ class ResolveStringResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string value = 1; */
         if (message.value !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.value);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.value);
         /* string reason = 2; */
         if (message.reason !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 3; */
         if (message.variant !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.variant);
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3771,7 +872,7 @@ class ResolveStringResponse$Type extends MessageType {
  */
 const ResolveStringResponse = new ResolveStringResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveFloatRequest$Type extends MessageType {
+class ResolveFloatRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveFloatRequest", [
             { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3780,9 +881,9 @@ class ResolveFloatRequest$Type extends MessageType {
     }
     create(value) {
         const message = { flagKey: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3802,7 +903,7 @@ class ResolveFloatRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3810,13 +911,13 @@ class ResolveFloatRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string flag_key = 1; */
         if (message.flagKey !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.flagKey);
         /* google.protobuf.Struct context = 2; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3825,7 +926,7 @@ class ResolveFloatRequest$Type extends MessageType {
  */
 const ResolveFloatRequest = new ResolveFloatRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveFloatResponse$Type extends MessageType {
+class ResolveFloatResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveFloatResponse", [
             { no: 1, name: "value", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
@@ -3835,9 +936,9 @@ class ResolveFloatResponse$Type extends MessageType {
     }
     create(value) {
         const message = { value: 0, reason: "", variant: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3860,7 +961,7 @@ class ResolveFloatResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3868,16 +969,16 @@ class ResolveFloatResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* double value = 1; */
         if (message.value !== 0)
-            writer.tag(1, WireType.Bit64).double(message.value);
+            writer.tag(1, runtime.WireType.Bit64).double(message.value);
         /* string reason = 2; */
         if (message.reason !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 3; */
         if (message.variant !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.variant);
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3886,7 +987,7 @@ class ResolveFloatResponse$Type extends MessageType {
  */
 const ResolveFloatResponse = new ResolveFloatResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveIntRequest$Type extends MessageType {
+class ResolveIntRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveIntRequest", [
             { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -3895,9 +996,9 @@ class ResolveIntRequest$Type extends MessageType {
     }
     create(value) {
         const message = { flagKey: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3917,7 +1018,7 @@ class ResolveIntRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3925,13 +1026,13 @@ class ResolveIntRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string flag_key = 1; */
         if (message.flagKey !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.flagKey);
         /* google.protobuf.Struct context = 2; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -3940,7 +1041,7 @@ class ResolveIntRequest$Type extends MessageType {
  */
 const ResolveIntRequest = new ResolveIntRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveIntResponse$Type extends MessageType {
+class ResolveIntResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveIntResponse", [
             { no: 1, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
@@ -3950,9 +1051,9 @@ class ResolveIntResponse$Type extends MessageType {
     }
     create(value) {
         const message = { value: "0", reason: "", variant: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -3975,7 +1076,7 @@ class ResolveIntResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -3983,16 +1084,16 @@ class ResolveIntResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* int64 value = 1; */
         if (message.value !== "0")
-            writer.tag(1, WireType.Varint).int64(message.value);
+            writer.tag(1, runtime.WireType.Varint).int64(message.value);
         /* string reason = 2; */
         if (message.reason !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 3; */
         if (message.variant !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.variant);
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -4001,7 +1102,7 @@ class ResolveIntResponse$Type extends MessageType {
  */
 const ResolveIntResponse = new ResolveIntResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveObjectRequest$Type extends MessageType {
+class ResolveObjectRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveObjectRequest", [
             { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -4010,9 +1111,9 @@ class ResolveObjectRequest$Type extends MessageType {
     }
     create(value) {
         const message = { flagKey: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -4032,7 +1133,7 @@ class ResolveObjectRequest$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -4040,13 +1141,13 @@ class ResolveObjectRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string flag_key = 1; */
         if (message.flagKey !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.flagKey);
         /* google.protobuf.Struct context = 2; */
         if (message.context)
-            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.context, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -4055,7 +1156,7 @@ class ResolveObjectRequest$Type extends MessageType {
  */
 const ResolveObjectRequest = new ResolveObjectRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ResolveObjectResponse$Type extends MessageType {
+class ResolveObjectResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.ResolveObjectResponse", [
             { no: 1, name: "value", kind: "message", T: () => Struct },
@@ -4065,9 +1166,9 @@ class ResolveObjectResponse$Type extends MessageType {
     }
     create(value) {
         const message = { reason: "", variant: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -4090,7 +1191,7 @@ class ResolveObjectResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -4098,16 +1199,16 @@ class ResolveObjectResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* google.protobuf.Struct value = 1; */
         if (message.value)
-            Struct.internalBinaryWrite(message.value, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.value, writer.tag(1, runtime.WireType.LengthDelimited).fork(), options).join();
         /* string reason = 2; */
         if (message.reason !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
         /* string variant = 3; */
         if (message.variant !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.variant);
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -4116,7 +1217,7 @@ class ResolveObjectResponse$Type extends MessageType {
  */
 const ResolveObjectResponse = new ResolveObjectResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class EventStreamResponse$Type extends MessageType {
+class EventStreamResponse$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.EventStreamResponse", [
             { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -4125,9 +1226,9 @@ class EventStreamResponse$Type extends MessageType {
     }
     create(value) {
         const message = { type: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -4147,7 +1248,7 @@ class EventStreamResponse$Type extends MessageType {
                         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);
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
             }
         }
         return message;
@@ -4155,13 +1256,13 @@ class EventStreamResponse$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         /* string type = 1; */
         if (message.type !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.type);
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.type);
         /* google.protobuf.Struct data = 2; */
         if (message.data)
-            Struct.internalBinaryWrite(message.data, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            Struct.internalBinaryWrite(message.data, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -4170,15 +1271,15 @@ class EventStreamResponse$Type extends MessageType {
  */
 const EventStreamResponse = new EventStreamResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class EventStreamRequest$Type extends MessageType {
+class EventStreamRequest$Type extends runtime.MessageType {
     constructor() {
         super("schema.v1.EventStreamRequest", []);
     }
     create(value) {
         const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        globalThis.Object.defineProperty(message, runtime.MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial(this, message, value);
+            runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
@@ -4187,7 +1288,7 @@ class EventStreamRequest$Type extends MessageType {
     internalBinaryWrite(message, writer, options) {
         let u = options.writeUnknownFields;
         if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -4276,13 +1377,45 @@ const Codes = {
     InvalidArgument: 'INVALID_ARGUMENT',
     NotFound: 'NOT_FOUND',
     DataLoss: 'DATA_LOSS',
-    Unavailable: 'UNAVAILABLE'
+    Unavailable: 'UNAVAILABLE',
 };
 class GRPCService {
-    constructor(config, client) {
-        this.onFulfilled = (value) => {
-            // no-op, just return the value
-            return value;
+    get _cacheActive() {
+        // the cache is "active" (able to be used) if the config enabled it, AND the gRPC stream is live
+        return this._cacheEnabled && this._streamAlive;
+    }
+    constructor(config, client, logger) {
+        var _a;
+        this.logger = logger;
+        this._cacheEnabled = false;
+        this._streamAlive = false;
+        this._streamConnectAttempt = 0;
+        this._streamConnectBackoff = BASE_EVENT_STREAM_RETRY_BACKOFF_MS;
+        // default to false here - reassigned in the constructor if we actaully need to connect
+        this.streamConnection = Promise.resolve(false);
+        this.objectParser = (struct) => {
+            if (struct) {
+                return Struct.toJson(struct);
+            }
+            return {};
+        };
+        this.booleanParser = (value) => {
+            if (value) {
+                return value;
+            }
+            return false;
+        };
+        this.stringParser = (value) => {
+            if (value) {
+                return value;
+            }
+            return '';
+        };
+        this.numberParser = (value) => {
+            if (value) {
+                return value;
+            }
+            return 0;
         };
         this.onRejected = (err) => {
             // map the errors
@@ -4300,70 +1433,136 @@ class GRPCService {
             }
         };
         const { host, port, tls, socketPath } = config;
-        this.client = client
+        this._maxEventStreamRetries = (_a = config.maxEventStreamRetries) !== null && _a !== void 0 ? _a : DEFAULT_MAX_EVENT_STREAM_RETRIES;
+        this._client = client
             ? client
             : new ServiceClient(new grpcTransport.GrpcTransport({
                 host: socketPath ? `unix://${socketPath}` : `${host}:${port}`,
-                channelCredentials: tls
-                    ? grpc__namespace.credentials.createSsl()
-                    : grpc__namespace.credentials.createInsecure(),
+                channelCredentials: tls ? grpc__namespace.credentials.createSsl() : grpc__namespace.credentials.createInsecure(),
             }));
+        // for now, we only need streaming if the cache is enabled (will need to be pulled out once we support events)
+        if (config.cache === 'lru') {
+            this._cacheEnabled = true;
+            this._cache = new LRU__default["default"]({ maxSize: config.maxCacheSize || DEFAULT_MAX_CACHE_SIZE, sizeCalculation: () => 1 });
+            this.streamConnection = this.connectStream();
+        }
     }
     resolveBoolean(flagKey, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { response } = yield this.client.resolveBoolean({
-                flagKey,
-                context: this.convertContext(context, logger),
-            }).then(this.onFulfilled, this.onRejected);
-            return {
-                value: response.value,
-                reason: response.reason,
-                variant: response.variant,
-            };
+            return this.resolve(this._client.resolveBoolean, flagKey, context, logger, this.booleanParser);
         });
     }
     resolveString(flagKey, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { response } = yield this.client.resolveString({
-                flagKey,
-                context: this.convertContext(context, logger),
-            }).then(this.onFulfilled, this.onRejected);
-            return {
-                value: response.value,
-                reason: response.reason,
-                variant: response.variant,
-            };
+            return this.resolve(this._client.resolveString, flagKey, context, logger, this.stringParser);
         });
     }
     resolveNumber(flagKey, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { response } = yield this.client.resolveFloat({
-                flagKey,
-                context: this.convertContext(context, logger),
-            }).then(this.onFulfilled, this.onRejected);
-            return {
-                value: response.value,
-                reason: response.reason,
-                variant: response.variant,
-            };
+            return this.resolve(this._client.resolveFloat, flagKey, context, logger, this.numberParser);
         });
     }
     resolveObject(flagKey, context, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { response } = yield this.client.resolveObject({
-                flagKey,
-                context: this.convertContext(context, logger),
-            }).then(this.onFulfilled, this.onRejected);
-            if (response.value !== undefined) {
-                return {
-                    value: Struct.toJson(response.value),
-                    reason: response.reason,
-                    variant: response.variant,
-                };
+            return this.resolve(this._client.resolveObject, flagKey, context, logger, this.objectParser);
+        });
+    }
+    connectStream() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: connecting stream, attempt ${this._streamConnectAttempt}...`);
+            const stream = this._client.eventStream({});
+            stream.responses.onError(() => {
+                this.handleError(reject);
+            });
+            stream.responses.onComplete(() => {
+                this.handleComplete();
+            });
+            stream.responses.onMessage((message) => {
+                if (message.type === EVENT_PROVIDER_READY) {
+                    this.handleProviderReady(resolve);
+                }
+                else if (message.type === EVENT_CONFIGURATION_CHANGE) {
+                    this.handleFlagsChanged(message);
+                }
+            });
+        });
+    }
+    handleProviderReady(resolve) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(`${FlagdProvider.name}: streaming connection established with flagd`);
+        this._streamAlive = true;
+        this._streamConnectAttempt = 0;
+        this._streamConnectBackoff = BASE_EVENT_STREAM_RETRY_BACKOFF_MS;
+        resolve(true);
+    }
+    handleFlagsChanged(message) {
+        var _a;
+        if (message.data) {
+            const data = Struct.toJson(message.data);
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: got message: ${JSON.stringify(data, undefined, 2)}`);
+            if (data && typeof data === 'object' && 'flags' in data && (data === null || data === void 0 ? void 0 : data['flags'])) {
+                const flagChangeMessage = data;
+                // remove each changed key from cache
+                Object.keys(flagChangeMessage.flags || []).forEach((key) => {
+                    var _a, _b;
+                    if ((_a = this._cache) === null || _a === void 0 ? void 0 : _a.delete(key)) {
+                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`${FlagdProvider.name}: evicted key: ${key} from cache.`);
+                    }
+                });
             }
-            else {
-                throw new jsSdk.ParseError('Object value undefined or missing.');
+        }
+    }
+    handleError(reject) {
+        var _a, _b, _c;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`${FlagdProvider.name}: streaming connection error, will attempt reconnect...`);
+        (_b = this._cache) === null || _b === void 0 ? void 0 : _b.clear();
+        this._streamAlive = false;
+        // if we haven't reached max attempt, reconnect after backoff
+        if (this._streamConnectAttempt <= this._maxEventStreamRetries) {
+            this._streamConnectAttempt++;
+            setTimeout(() => {
+                this._streamConnectBackoff = this._streamConnectBackoff * 2;
+                this.connectStream();
+            }, this._streamConnectBackoff);
+        }
+        else {
+            // after max attempts, give up
+            const errorMessage = `${FlagdProvider.name}: max stream connect attempts (${this._maxEventStreamRetries} reached)`;
+            (_c = this.logger) === null || _c === void 0 ? void 0 : _c.error(errorMessage);
+            reject(new Error(errorMessage));
+        }
+    }
+    handleComplete() {
+        var _a, _b;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(`${FlagdProvider.name}: streaming connection closed gracefully`);
+        (_b = this._cache) === null || _b === void 0 ? void 0 : _b.clear();
+        this._streamAlive = false;
+    }
+    resolve(resolver, flagKey, context, logger, parser) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._cacheActive) {
+                const cached = (_a = this._cache) === null || _a === void 0 ? void 0 : _a.get(flagKey);
+                if (cached) {
+                    return Object.assign(Object.assign({}, cached), { reason: jsSdk.StandardResolutionReasons.CACHED });
+                }
             }
+            // invoke the passed resolver method
+            const { response } = yield resolver
+                .call(this._client, { flagKey, context: this.convertContext(context, logger) })
+                .then((resolved) => resolved, this.onRejected);
+            const resolved = {
+                // invoke the parser method if passed
+                value: parser ? parser.call(this, response.value) : response.value,
+                reason: response.reason,
+                variant: response.variant,
+            };
+            if (this._cacheActive && response.reason === jsSdk.StandardResolutionReasons.STATIC) {
+                // cache this static value
+                (_b = this._cache) === null || _b === void 0 ? void 0 : _b.set(flagKey, Object.assign({}, resolved));
+            }
+            return resolved;
         });
     }
     convertContext(context, logger) {
@@ -4382,7 +1581,19 @@ class GRPCService {
 }
 
 class FlagdProvider {
-    constructor(options, service) {
+    /**
+     * Promise indicating the gRPC stream is connected.
+     *
+     * Can be used in instances where the provider being connected to the event stream is a prerequisite
+     * to execution (e.g. testing). Not necessary for standard usage.
+     *
+     * @returns true if stream connected successfully, false if connection not enabled.
+     */
+    get streamConnection() {
+        return this._service.streamConnection;
+    }
+    constructor(options, service, logger) {
+        this.logger = logger;
         this.metadata = {
             name: 'flagd Provider',
         };
@@ -4391,22 +1602,26 @@ class FlagdProvider {
             logger.error(err === null || err === void 0 ? void 0 : err.stack);
             throw err;
         };
-        this._service = service ? service : new GRPCService(getConfig(options));
+        this._service = service ? service : new GRPCService(getConfig(options), undefined, logger);
     }
     resolveBooleanEvaluation(flagKey, _, transformedContext, logger) {
-        return this._service.resolveBoolean(flagKey, transformedContext, logger)
+        return this._service
+            .resolveBoolean(flagKey, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
     resolveStringEvaluation(flagKey, _, transformedContext, logger) {
-        return this._service.resolveString(flagKey, transformedContext, logger)
+        return this._service
+            .resolveString(flagKey, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
     resolveNumberEvaluation(flagKey, _, transformedContext, logger) {
-        return this._service.resolveNumber(flagKey, transformedContext, logger)
+        return this._service
+            .resolveNumber(flagKey, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
     resolveObjectEvaluation(flagKey, _, transformedContext, logger) {
-        return this._service.resolveObject(flagKey, transformedContext, logger)
+        return this._service
+            .resolveObject(flagKey, transformedContext, logger)
             .catch((err) => this.logRejected(err, flagKey, logger));
     }
 }