☰

Discord Status Remote Control

Toggle Discord online status without entering the app first

  1. // ==UserScript==
  2. // @name         Discord Status Remote Control
  3. // @namespace    https://discord.com/
  4. // @version      0.1.1
  5. // @description  Toggle Discord online status without entering the app first
  6. // @author       d0gkiller87
  7. // @match        https://discord.com/*
  8. // @exclude      https://discord.com/channels/*
  9. // @icon         https://www.google.com/s2/favicons?sz=64&domain=discord.com
  10. // @grant        GM_addStyle
  11. // @grant        GM_xmlhttpRequest
  12. // @run-at       document-start
  13. // @license      MIT
  14. // ==/UserScript==
  15.  
  16. // node_modules/@protobuf-ts/runtime/build/es2015/json-typings.js
  17. function typeofJsonValue(value) {
  18.   let t = typeof value;
  19.   if (t == "object") {
  20.     if (Array.isArray(value))
  21.       return "array";
  22.     if (value === null)
  23.       return "null";
  24.   }
  25.   return t;
  26. }
  27. function isJsonObject(value) {
  28.   return value !== null && typeof value == "object" && !Array.isArray(value);
  29. }
  30. // node_modules/@protobuf-ts/runtime/build/es2015/base64.js
  31. var encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
  32. var decTable = [];
  33. for (let i = 0;i < encTable.length; i++)
  34.   decTable[encTable[i].charCodeAt(0)] = i;
  35. decTable[45] = encTable.indexOf("+");
  36. decTable[95] = encTable.indexOf("/");
  37. function base64decode(base64Str) {
  38.   let es = base64Str.length * 3 / 4;
  39.   if (base64Str[base64Str.length - 2] == "=")
  40.     es -= 2;
  41.   else if (base64Str[base64Str.length - 1] == "=")
  42.     es -= 1;
  43.   let bytes = new Uint8Array(es), bytePos = 0, groupPos = 0, b, p = 0;
  44.   for (let i = 0;i < base64Str.length; i++) {
  45.     b = decTable[base64Str.charCodeAt(i)];
  46.     if (b === undefined) {
  47.       switch (base64Str[i]) {
  48.         case "=":
  49.           groupPos = 0;
  50.         case `
  51. `:
  52.         case "\r":
  53.         case "\t":
  54.         case " ":
  55.           continue;
  56.         default:
  57.           throw Error(`invalid base64 string.`);
  58.       }
  59.     }
  60.     switch (groupPos) {
  61.       case 0:
  62.         p = b;
  63.         groupPos = 1;
  64.         break;
  65.       case 1:
  66.         bytes[bytePos++] = p << 2 | (b & 48) >> 4;
  67.         p = b;
  68.         groupPos = 2;
  69.         break;
  70.       case 2:
  71.         bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
  72.         p = b;
  73.         groupPos = 3;
  74.         break;
  75.       case 3:
  76.         bytes[bytePos++] = (p & 3) << 6 | b;
  77.         groupPos = 0;
  78.         break;
  79.     }
  80.   }
  81.   if (groupPos == 1)
  82.     throw Error(`invalid base64 string.`);
  83.   return bytes.subarray(0, bytePos);
  84. }
  85. function base64encode(bytes) {
  86.   let base64 = "", groupPos = 0, b, p = 0;
  87.   for (let i = 0;i < bytes.length; i++) {
  88.     b = bytes[i];
  89.     switch (groupPos) {
  90.       case 0:
  91.         base64 += encTable[b >> 2];
  92.         p = (b & 3) << 4;
  93.         groupPos = 1;
  94.         break;
  95.       case 1:
  96.         base64 += encTable[p | b >> 4];
  97.         p = (b & 15) << 2;
  98.         groupPos = 2;
  99.         break;
  100.       case 2:
  101.         base64 += encTable[p | b >> 6];
  102.         base64 += encTable[b & 63];
  103.         groupPos = 0;
  104.         break;
  105.     }
  106.   }
  107.   if (groupPos) {
  108.     base64 += encTable[p];
  109.     base64 += "=";
  110.     if (groupPos == 1)
  111.       base64 += "=";
  112.   }
  113.   return base64;
  114. }
  115.  
  116. // node_modules/@protobuf-ts/runtime/build/es2015/binary-format-contract.js
  117. var UnknownFieldHandler;
  118. (function(UnknownFieldHandler2) {
  119.   UnknownFieldHandler2.symbol = Symbol.for("protobuf-ts/unknown");
  120.   UnknownFieldHandler2.onRead = (typeName, message, fieldNo, wireType, data) => {
  121.     let container = is(message) ? message[UnknownFieldHandler2.symbol] : message[UnknownFieldHandler2.symbol] = [];
  122.     container.push({ no: fieldNo, wireType, data });
  123.   };
  124.   UnknownFieldHandler2.onWrite = (typeName, message, writer) => {
  125.     for (let { no, wireType, data } of UnknownFieldHandler2.list(message))
  126.       writer.tag(no, wireType).raw(data);
  127.   };
  128.   UnknownFieldHandler2.list = (message, fieldNo) => {
  129.     if (is(message)) {
  130.       let all = message[UnknownFieldHandler2.symbol];
  131.       return fieldNo ? all.filter((uf) => uf.no == fieldNo) : all;
  132.     }
  133.     return [];
  134.   };
  135.   UnknownFieldHandler2.last = (message, fieldNo) => UnknownFieldHandler2.list(message, fieldNo).slice(-1)[0];
  136.   const is = (message) => message && Array.isArray(message[UnknownFieldHandler2.symbol]);
  137. })(UnknownFieldHandler || (UnknownFieldHandler = {}));
  138. var WireType;
  139. (function(WireType2) {
  140.   WireType2[WireType2["Varint"] = 0] = "Varint";
  141.   WireType2[WireType2["Bit64"] = 1] = "Bit64";
  142.   WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
  143.   WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
  144.   WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
  145.   WireType2[WireType2["Bit32"] = 5] = "Bit32";
  146. })(WireType || (WireType = {}));
  147. // node_modules/@protobuf-ts/runtime/build/es2015/goog-varint.js
  148. function varint64read() {
  149.   let lowBits = 0;
  150.   let highBits = 0;
  151.   for (let shift = 0;shift < 28; shift += 7) {
  152.     let b = this.buf[this.pos++];
  153.     lowBits |= (b & 127) << shift;
  154.     if ((b & 128) == 0) {
  155.       this.assertBounds();
  156.       return [lowBits, highBits];
  157.     }
  158.   }
  159.   let middleByte = this.buf[this.pos++];
  160.   lowBits |= (middleByte & 15) << 28;
  161.   highBits = (middleByte & 112) >> 4;
  162.   if ((middleByte & 128) == 0) {
  163.     this.assertBounds();
  164.     return [lowBits, highBits];
  165.   }
  166.   for (let shift = 3;shift <= 31; shift += 7) {
  167.     let b = this.buf[this.pos++];
  168.     highBits |= (b & 127) << shift;
  169.     if ((b & 128) == 0) {
  170.       this.assertBounds();
  171.       return [lowBits, highBits];
  172.     }
  173.   }
  174.   throw new Error("invalid varint");
  175. }
  176. function varint64write(lo, hi, bytes) {
  177.   for (let i = 0;i < 28; i = i + 7) {
  178.     const shift = lo >>> i;
  179.     const hasNext = !(shift >>> 7 == 0 && hi == 0);
  180.     const byte = (hasNext ? shift | 128 : shift) & 255;
  181.     bytes.push(byte);
  182.     if (!hasNext) {
  183.       return;
  184.     }
  185.   }
  186.   const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
  187.   const hasMoreBits = !(hi >> 3 == 0);
  188.   bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
  189.   if (!hasMoreBits) {
  190.     return;
  191.   }
  192.   for (let i = 3;i < 31; i = i + 7) {
  193.     const shift = hi >>> i;
  194.     const hasNext = !(shift >>> 7 == 0);
  195.     const byte = (hasNext ? shift | 128 : shift) & 255;
  196.     bytes.push(byte);
  197.     if (!hasNext) {
  198.       return;
  199.     }
  200.   }
  201.   bytes.push(hi >>> 31 & 1);
  202. }
  203. var TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
  204. function int64fromString(dec) {
  205.   let minus = dec[0] == "-";
  206.   if (minus)
  207.     dec = dec.slice(1);
  208.   const base = 1e6;
  209.   let lowBits = 0;
  210.   let highBits = 0;
  211.   function add1e6digit(begin, end) {
  212.     const digit1e6 = Number(dec.slice(begin, end));
  213.     highBits *= base;
  214.     lowBits = lowBits * base + digit1e6;
  215.     if (lowBits >= TWO_PWR_32_DBL) {
  216.       highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
  217.       lowBits = lowBits % TWO_PWR_32_DBL;
  218.     }
  219.   }
  220.   add1e6digit(-24, -18);
  221.   add1e6digit(-18, -12);
  222.   add1e6digit(-12, -6);
  223.   add1e6digit(-6);
  224.   return [minus, lowBits, highBits];
  225. }
  226. function int64toString(bitsLow, bitsHigh) {
  227.   if (bitsHigh >>> 0 <= 2097151) {
  228.     return "" + (TWO_PWR_32_DBL * bitsHigh + (bitsLow >>> 0));
  229.   }
  230.   let low = bitsLow & 16777215;
  231.   let mid = (bitsLow >>> 24 | bitsHigh << 8) >>> 0 & 16777215;
  232.   let high = bitsHigh >> 16 & 65535;
  233.   let digitA = low + mid * 6777216 + high * 6710656;
  234.   let digitB = mid + high * 8147497;
  235.   let digitC = high * 2;
  236.   let base = 1e7;
  237.   if (digitA >= base) {
  238.     digitB += Math.floor(digitA / base);
  239.     digitA %= base;
  240.   }
  241.   if (digitB >= base) {
  242.     digitC += Math.floor(digitB / base);
  243.     digitB %= base;
  244.   }
  245.   function decimalFrom1e7(digit1e7, needLeadingZeros) {
  246.     let partial = digit1e7 ? String(digit1e7) : "";
  247.     if (needLeadingZeros) {
  248.       return "0000000".slice(partial.length) + partial;
  249.     }
  250.     return partial;
  251.   }
  252.   return decimalFrom1e7(digitC, 0) + decimalFrom1e7(digitB, digitC) + decimalFrom1e7(digitA, 1);
  253. }
  254. function varint32write(value, bytes) {
  255.   if (value >= 0) {
  256.     while (value > 127) {
  257.       bytes.push(value & 127 | 128);
  258.       value = value >>> 7;
  259.     }
  260.     bytes.push(value);
  261.   } else {
  262.     for (let i = 0;i < 9; i++) {
  263.       bytes.push(value & 127 | 128);
  264.       value = value >> 7;
  265.     }
  266.     bytes.push(1);
  267.   }
  268. }
  269. function varint32read() {
  270.   let b = this.buf[this.pos++];
  271.   let result = b & 127;
  272.   if ((b & 128) == 0) {
  273.     this.assertBounds();
  274.     return result;
  275.   }
  276.   b = this.buf[this.pos++];
  277.   result |= (b & 127) << 7;
  278.   if ((b & 128) == 0) {
  279.     this.assertBounds();
  280.     return result;
  281.   }
  282.   b = this.buf[this.pos++];
  283.   result |= (b & 127) << 14;
  284.   if ((b & 128) == 0) {
  285.     this.assertBounds();
  286.     return result;
  287.   }
  288.   b = this.buf[this.pos++];
  289.   result |= (b & 127) << 21;
  290.   if ((b & 128) == 0) {
  291.     this.assertBounds();
  292.     return result;
  293.   }
  294.   b = this.buf[this.pos++];
  295.   result |= (b & 15) << 28;
  296.   for (let readBytes = 5;(b & 128) !== 0 && readBytes < 10; readBytes++)
  297.     b = this.buf[this.pos++];
  298.   if ((b & 128) != 0)
  299.     throw new Error("invalid varint");
  300.   this.assertBounds();
  301.   return result >>> 0;
  302. }
  303.  
  304. // node_modules/@protobuf-ts/runtime/build/es2015/pb-long.js
  305. var BI;
  306. function detectBi() {
  307.   const dv = new DataView(new ArrayBuffer(8));
  308.   const ok = globalThis.BigInt !== undefined && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function";
  309.   BI = ok ? {
  310.     MIN: BigInt("-9223372036854775808"),
  311.     MAX: BigInt("9223372036854775807"),
  312.     UMIN: BigInt("0"),
  313.     UMAX: BigInt("18446744073709551615"),
  314.     C: BigInt,
  315.     V: dv
  316.   } : undefined;
  317. }
  318. detectBi();
  319. function assertBi(bi) {
  320.   if (!bi)
  321.     throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support");
  322. }
  323. var RE_DECIMAL_STR = /^-?[0-9]+$/;
  324. var TWO_PWR_32_DBL2 = 4294967296;
  325. var HALF_2_PWR_32 = 2147483648;
  326.  
  327. class SharedPbLong {
  328.   constructor(lo, hi) {
  329.     this.lo = lo | 0;
  330.     this.hi = hi | 0;
  331.   }
  332.   isZero() {
  333.     return this.lo == 0 && this.hi == 0;
  334.   }
  335.   toNumber() {
  336.     let result = this.hi * TWO_PWR_32_DBL2 + (this.lo >>> 0);
  337.     if (!Number.isSafeInteger(result))
  338.       throw new Error("cannot convert to safe number");
  339.     return result;
  340.   }
  341. }
  342.  
  343. class PbULong extends SharedPbLong {
  344.   static from(value) {
  345.     if (BI)
  346.       switch (typeof value) {
  347.         case "string":
  348.           if (value == "0")
  349.             return this.ZERO;
  350.           if (value == "")
  351.             throw new Error("string is no integer");
  352.           value = BI.C(value);
  353.         case "number":
  354.           if (value === 0)
  355.             return this.ZERO;
  356.           value = BI.C(value);
  357.         case "bigint":
  358.           if (!value)
  359.             return this.ZERO;
  360.           if (value < BI.UMIN)
  361.             throw new Error("signed value for ulong");
  362.           if (value > BI.UMAX)
  363.             throw new Error("ulong too large");
  364.           BI.V.setBigUint64(0, value, true);
  365.           return new PbULong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
  366.       }
  367.     else
  368.       switch (typeof value) {
  369.         case "string":
  370.           if (value == "0")
  371.             return this.ZERO;
  372.           value = value.trim();
  373.           if (!RE_DECIMAL_STR.test(value))
  374.             throw new Error("string is no integer");
  375.           let [minus, lo, hi] = int64fromString(value);
  376.           if (minus)
  377.             throw new Error("signed value for ulong");
  378.           return new PbULong(lo, hi);
  379.         case "number":
  380.           if (value == 0)
  381.             return this.ZERO;
  382.           if (!Number.isSafeInteger(value))
  383.             throw new Error("number is no integer");
  384.           if (value < 0)
  385.             throw new Error("signed value for ulong");
  386.           return new PbULong(value, value / TWO_PWR_32_DBL2);
  387.       }
  388.     throw new Error("unknown value " + typeof value);
  389.   }
  390.   toString() {
  391.     return BI ? this.toBigInt().toString() : int64toString(this.lo, this.hi);
  392.   }
  393.   toBigInt() {
  394.     assertBi(BI);
  395.     BI.V.setInt32(0, this.lo, true);
  396.     BI.V.setInt32(4, this.hi, true);
  397.     return BI.V.getBigUint64(0, true);
  398.   }
  399. }
  400. PbULong.ZERO = new PbULong(0, 0);
  401.  
  402. class PbLong extends SharedPbLong {
  403.   static from(value) {
  404.     if (BI)
  405.       switch (typeof value) {
  406.         case "string":
  407.           if (value == "0")
  408.             return this.ZERO;
  409.           if (value == "")
  410.             throw new Error("string is no integer");
  411.           value = BI.C(value);
  412.         case "number":
  413.           if (value === 0)
  414.             return this.ZERO;
  415.           value = BI.C(value);
  416.         case "bigint":
  417.           if (!value)
  418.             return this.ZERO;
  419.           if (value < BI.MIN)
  420.             throw new Error("signed long too small");
  421.           if (value > BI.MAX)
  422.             throw new Error("signed long too large");
  423.           BI.V.setBigInt64(0, value, true);
  424.           return new PbLong(BI.V.getInt32(0, true), BI.V.getInt32(4, true));
  425.       }
  426.     else
  427.       switch (typeof value) {
  428.         case "string":
  429.           if (value == "0")
  430.             return this.ZERO;
  431.           value = value.trim();
  432.           if (!RE_DECIMAL_STR.test(value))
  433.             throw new Error("string is no integer");
  434.           let [minus, lo, hi] = int64fromString(value);
  435.           if (minus) {
  436.             if (hi > HALF_2_PWR_32 || hi == HALF_2_PWR_32 && lo != 0)
  437.               throw new Error("signed long too small");
  438.           } else if (hi >= HALF_2_PWR_32)
  439.             throw new Error("signed long too large");
  440.           let pbl = new PbLong(lo, hi);
  441.           return minus ? pbl.negate() : pbl;
  442.         case "number":
  443.           if (value == 0)
  444.             return this.ZERO;
  445.           if (!Number.isSafeInteger(value))
  446.             throw new Error("number is no integer");
  447.           return value > 0 ? new PbLong(value, value / TWO_PWR_32_DBL2) : new PbLong(-value, -value / TWO_PWR_32_DBL2).negate();
  448.       }
  449.     throw new Error("unknown value " + typeof value);
  450.   }
  451.   isNegative() {
  452.     return (this.hi & HALF_2_PWR_32) !== 0;
  453.   }
  454.   negate() {
  455.     let hi = ~this.hi, lo = this.lo;
  456.     if (lo)
  457.       lo = ~lo + 1;
  458.     else
  459.       hi += 1;
  460.     return new PbLong(lo, hi);
  461.   }
  462.   toString() {
  463.     if (BI)
  464.       return this.toBigInt().toString();
  465.     if (this.isNegative()) {
  466.       let n = this.negate();
  467.       return "-" + int64toString(n.lo, n.hi);
  468.     }
  469.     return int64toString(this.lo, this.hi);
  470.   }
  471.   toBigInt() {
  472.     assertBi(BI);
  473.     BI.V.setInt32(0, this.lo, true);
  474.     BI.V.setInt32(4, this.hi, true);
  475.     return BI.V.getBigInt64(0, true);
  476.   }
  477. }
  478. PbLong.ZERO = new PbLong(0, 0);
  479.  
  480. // node_modules/@protobuf-ts/runtime/build/es2015/binary-reader.js
  481. var defaultsRead = {
  482.   readUnknownField: true,
  483.   readerFactory: (bytes) => new BinaryReader(bytes)
  484. };
  485. function binaryReadOptions(options) {
  486.   return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead;
  487. }
  488.  
  489. class BinaryReader {
  490.   constructor(buf, textDecoder) {
  491.     this.varint64 = varint64read;
  492.     this.uint32 = varint32read;
  493.     this.buf = buf;
  494.     this.len = buf.length;
  495.     this.pos = 0;
  496.     this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  497.     this.textDecoder = textDecoder !== null && textDecoder !== undefined ? textDecoder : new TextDecoder("utf-8", {
  498.       fatal: true,
  499.       ignoreBOM: true
  500.     });
  501.   }
  502.   tag() {
  503.     let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
  504.     if (fieldNo <= 0 || wireType < 0 || wireType > 5)
  505.       throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
  506.     return [fieldNo, wireType];
  507.   }
  508.   skip(wireType) {
  509.     let start = this.pos;
  510.     switch (wireType) {
  511.       case WireType.Varint:
  512.         while (this.buf[this.pos++] & 128) {}
  513.         break;
  514.       case WireType.Bit64:
  515.         this.pos += 4;
  516.       case WireType.Bit32:
  517.         this.pos += 4;
  518.         break;
  519.       case WireType.LengthDelimited:
  520.         let len = this.uint32();
  521.         this.pos += len;
  522.         break;
  523.       case WireType.StartGroup:
  524.         let t;
  525.         while ((t = this.tag()[1]) !== WireType.EndGroup) {
  526.           this.skip(t);
  527.         }
  528.         break;
  529.       default:
  530.         throw new Error("cant skip wire type " + wireType);
  531.     }
  532.     this.assertBounds();
  533.     return this.buf.subarray(start, this.pos);
  534.   }
  535.   assertBounds() {
  536.     if (this.pos > this.len)
  537.       throw new RangeError("premature EOF");
  538.   }
  539.   int32() {
  540.     return this.uint32() | 0;
  541.   }
  542.   sint32() {
  543.     let zze = this.uint32();
  544.     return zze >>> 1 ^ -(zze & 1);
  545.   }
  546.   int64() {
  547.     return new PbLong(...this.varint64());
  548.   }
  549.   uint64() {
  550.     return new PbULong(...this.varint64());
  551.   }
  552.   sint64() {
  553.     let [lo, hi] = this.varint64();
  554.     let s = -(lo & 1);
  555.     lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
  556.     hi = hi >>> 1 ^ s;
  557.     return new PbLong(lo, hi);
  558.   }
  559.   bool() {
  560.     let [lo, hi] = this.varint64();
  561.     return lo !== 0 || hi !== 0;
  562.   }
  563.   fixed32() {
  564.     return this.view.getUint32((this.pos += 4) - 4, true);
  565.   }
  566.   sfixed32() {
  567.     return this.view.getInt32((this.pos += 4) - 4, true);
  568.   }
  569.   fixed64() {
  570.     return new PbULong(this.sfixed32(), this.sfixed32());
  571.   }
  572.   sfixed64() {
  573.     return new PbLong(this.sfixed32(), this.sfixed32());
  574.   }
  575.   float() {
  576.     return this.view.getFloat32((this.pos += 4) - 4, true);
  577.   }
  578.   double() {
  579.     return this.view.getFloat64((this.pos += 8) - 8, true);
  580.   }
  581.   bytes() {
  582.     let len = this.uint32();
  583.     let start = this.pos;
  584.     this.pos += len;
  585.     this.assertBounds();
  586.     return this.buf.subarray(start, start + len);
  587.   }
  588.   string() {
  589.     return this.textDecoder.decode(this.bytes());
  590.   }
  591. }
  592.  
  593. // node_modules/@protobuf-ts/runtime/build/es2015/assert.js
  594. function assert(condition, msg) {
  595.   if (!condition) {
  596.     throw new Error(msg);
  597.   }
  598. }
  599. var FLOAT32_MAX = 340282346638528860000000000000000000000;
  600. var FLOAT32_MIN = -340282346638528860000000000000000000000;
  601. var UINT32_MAX = 4294967295;
  602. var INT32_MAX = 2147483647;
  603. var INT32_MIN = -2147483648;
  604. function assertInt32(arg) {
  605.   if (typeof arg !== "number")
  606.     throw new Error("invalid int 32: " + typeof arg);
  607.   if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
  608.     throw new Error("invalid int 32: " + arg);
  609. }
  610. function assertUInt32(arg) {
  611.   if (typeof arg !== "number")
  612.     throw new Error("invalid uint 32: " + typeof arg);
  613.   if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
  614.     throw new Error("invalid uint 32: " + arg);
  615. }
  616. function assertFloat32(arg) {
  617.   if (typeof arg !== "number")
  618.     throw new Error("invalid float 32: " + typeof arg);
  619.   if (!Number.isFinite(arg))
  620.     return;
  621.   if (arg > FLOAT32_MAX || arg < FLOAT32_MIN)
  622.     throw new Error("invalid float 32: " + arg);
  623. }
  624.  
  625. // node_modules/@protobuf-ts/runtime/build/es2015/binary-writer.js
  626. var defaultsWrite = {
  627.   writeUnknownFields: true,
  628.   writerFactory: () => new BinaryWriter
  629. };
  630. function binaryWriteOptions(options) {
  631.   return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite;
  632. }
  633.  
  634. class BinaryWriter {
  635.   constructor(textEncoder) {
  636.     this.stack = [];
  637.     this.textEncoder = textEncoder !== null && textEncoder !== undefined ? textEncoder : new TextEncoder;
  638.     this.chunks = [];
  639.     this.buf = [];
  640.   }
  641.   finish() {
  642.     this.chunks.push(new Uint8Array(this.buf));
  643.     let len = 0;
  644.     for (let i = 0;i < this.chunks.length; i++)
  645.       len += this.chunks[i].length;
  646.     let bytes = new Uint8Array(len);
  647.     let offset = 0;
  648.     for (let i = 0;i < this.chunks.length; i++) {
  649.       bytes.set(this.chunks[i], offset);
  650.       offset += this.chunks[i].length;
  651.     }
  652.     this.chunks = [];
  653.     return bytes;
  654.   }
  655.   fork() {
  656.     this.stack.push({ chunks: this.chunks, buf: this.buf });
  657.     this.chunks = [];
  658.     this.buf = [];
  659.     return this;
  660.   }
  661.   join() {
  662.     let chunk = this.finish();
  663.     let prev = this.stack.pop();
  664.     if (!prev)
  665.       throw new Error("invalid state, fork stack empty");
  666.     this.chunks = prev.chunks;
  667.     this.buf = prev.buf;
  668.     this.uint32(chunk.byteLength);
  669.     return this.raw(chunk);
  670.   }
  671.   tag(fieldNo, type) {
  672.     return this.uint32((fieldNo << 3 | type) >>> 0);
  673.   }
  674.   raw(chunk) {
  675.     if (this.buf.length) {
  676.       this.chunks.push(new Uint8Array(this.buf));
  677.       this.buf = [];
  678.     }
  679.     this.chunks.push(chunk);
  680.     return this;
  681.   }
  682.   uint32(value) {
  683.     assertUInt32(value);
  684.     while (value > 127) {
  685.       this.buf.push(value & 127 | 128);
  686.       value = value >>> 7;
  687.     }
  688.     this.buf.push(value);
  689.     return this;
  690.   }
  691.   int32(value) {
  692.     assertInt32(value);
  693.     varint32write(value, this.buf);
  694.     return this;
  695.   }
  696.   bool(value) {
  697.     this.buf.push(value ? 1 : 0);
  698.     return this;
  699.   }
  700.   bytes(value) {
  701.     this.uint32(value.byteLength);
  702.     return this.raw(value);
  703.   }
  704.   string(value) {
  705.     let chunk = this.textEncoder.encode(value);
  706.     this.uint32(chunk.byteLength);
  707.     return this.raw(chunk);
  708.   }
  709.   float(value) {
  710.     assertFloat32(value);
  711.     let chunk = new Uint8Array(4);
  712.     new DataView(chunk.buffer).setFloat32(0, value, true);
  713.     return this.raw(chunk);
  714.   }
  715.   double(value) {
  716.     let chunk = new Uint8Array(8);
  717.     new DataView(chunk.buffer).setFloat64(0, value, true);
  718.     return this.raw(chunk);
  719.   }
  720.   fixed32(value) {
  721.     assertUInt32(value);
  722.     let chunk = new Uint8Array(4);
  723.     new DataView(chunk.buffer).setUint32(0, value, true);
  724.     return this.raw(chunk);
  725.   }
  726.   sfixed32(value) {
  727.     assertInt32(value);
  728.     let chunk = new Uint8Array(4);
  729.     new DataView(chunk.buffer).setInt32(0, value, true);
  730.     return this.raw(chunk);
  731.   }
  732.   sint32(value) {
  733.     assertInt32(value);
  734.     value = (value << 1 ^ value >> 31) >>> 0;
  735.     varint32write(value, this.buf);
  736.     return this;
  737.   }
  738.   sfixed64(value) {
  739.     let chunk = new Uint8Array(8);
  740.     let view = new DataView(chunk.buffer);
  741.     let long = PbLong.from(value);
  742.     view.setInt32(0, long.lo, true);
  743.     view.setInt32(4, long.hi, true);
  744.     return this.raw(chunk);
  745.   }
  746.   fixed64(value) {
  747.     let chunk = new Uint8Array(8);
  748.     let view = new DataView(chunk.buffer);
  749.     let long = PbULong.from(value);
  750.     view.setInt32(0, long.lo, true);
  751.     view.setInt32(4, long.hi, true);
  752.     return this.raw(chunk);
  753.   }
  754.   int64(value) {
  755.     let long = PbLong.from(value);
  756.     varint64write(long.lo, long.hi, this.buf);
  757.     return this;
  758.   }
  759.   sint64(value) {
  760.     let long = PbLong.from(value), sign = long.hi >> 31, lo = long.lo << 1 ^ sign, hi = (long.hi << 1 | long.lo >>> 31) ^ sign;
  761.     varint64write(lo, hi, this.buf);
  762.     return this;
  763.   }
  764.   uint64(value) {
  765.     let long = PbULong.from(value);
  766.     varint64write(long.lo, long.hi, this.buf);
  767.     return this;
  768.   }
  769. }
  770. // node_modules/@protobuf-ts/runtime/build/es2015/json-format-contract.js
  771. var defaultsWrite2 = {
  772.   emitDefaultValues: false,
  773.   enumAsInteger: false,
  774.   useProtoFieldName: false,
  775.   prettySpaces: 0
  776. };
  777. var defaultsRead2 = {
  778.   ignoreUnknownFields: false
  779. };
  780. function jsonReadOptions(options) {
  781.   return options ? Object.assign(Object.assign({}, defaultsRead2), options) : defaultsRead2;
  782. }
  783. function jsonWriteOptions(options) {
  784.   return options ? Object.assign(Object.assign({}, defaultsWrite2), options) : defaultsWrite2;
  785. }
  786.  
  787. // node_modules/@protobuf-ts/runtime/build/es2015/message-type-contract.js
  788. var MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type");
  789.  
  790. // node_modules/@protobuf-ts/runtime/build/es2015/lower-camel-case.js
  791. function lowerCamelCase(snakeCase) {
  792.   let capNext = false;
  793.   const sb = [];
  794.   for (let i = 0;i < snakeCase.length; i++) {
  795.     let next = snakeCase.charAt(i);
  796.     if (next == "_") {
  797.       capNext = true;
  798.     } else if (/\d/.test(next)) {
  799.       sb.push(next);
  800.       capNext = true;
  801.     } else if (capNext) {
  802.       sb.push(next.toUpperCase());
  803.       capNext = false;
  804.     } else if (i == 0) {
  805.       sb.push(next.toLowerCase());
  806.     } else {
  807.       sb.push(next);
  808.     }
  809.   }
  810.   return sb.join("");
  811. }
  812.  
  813. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-info.js
  814. var ScalarType;
  815. (function(ScalarType2) {
  816.   ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
  817.   ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
  818.   ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
  819.   ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
  820.   ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
  821.   ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
  822.   ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
  823.   ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
  824.   ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
  825.   ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
  826.   ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
  827.   ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
  828.   ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
  829.   ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
  830.   ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
  831. })(ScalarType || (ScalarType = {}));
  832. var LongType;
  833. (function(LongType2) {
  834.   LongType2[LongType2["BIGINT"] = 0] = "BIGINT";
  835.   LongType2[LongType2["STRING"] = 1] = "STRING";
  836.   LongType2[LongType2["NUMBER"] = 2] = "NUMBER";
  837. })(LongType || (LongType = {}));
  838. var RepeatType;
  839. (function(RepeatType2) {
  840.   RepeatType2[RepeatType2["NO"] = 0] = "NO";
  841.   RepeatType2[RepeatType2["PACKED"] = 1] = "PACKED";
  842.   RepeatType2[RepeatType2["UNPACKED"] = 2] = "UNPACKED";
  843. })(RepeatType || (RepeatType = {}));
  844. function normalizeFieldInfo(field) {
  845.   var _a, _b, _c, _d;
  846.   field.localName = (_a = field.localName) !== null && _a !== undefined ? _a : lowerCamelCase(field.name);
  847.   field.jsonName = (_b = field.jsonName) !== null && _b !== undefined ? _b : lowerCamelCase(field.name);
  848.   field.repeat = (_c = field.repeat) !== null && _c !== undefined ? _c : RepeatType.NO;
  849.   field.opt = (_d = field.opt) !== null && _d !== undefined ? _d : field.repeat ? false : field.oneof ? false : field.kind == "message";
  850.   return field;
  851. }
  852.  
  853. // node_modules/@protobuf-ts/runtime/build/es2015/oneof.js
  854. function isOneofGroup(any) {
  855.   if (typeof any != "object" || any === null || !any.hasOwnProperty("oneofKind")) {
  856.     return false;
  857.   }
  858.   switch (typeof any.oneofKind) {
  859.     case "string":
  860.       if (any[any.oneofKind] === undefined)
  861.         return false;
  862.       return Object.keys(any).length == 2;
  863.     case "undefined":
  864.       return Object.keys(any).length == 1;
  865.     default:
  866.       return false;
  867.   }
  868. }
  869.  
  870. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-type-check.js
  871. class ReflectionTypeCheck {
  872.   constructor(info) {
  873.     var _a;
  874.     this.fields = (_a = info.fields) !== null && _a !== undefined ? _a : [];
  875.   }
  876.   prepare() {
  877.     if (this.data)
  878.       return;
  879.     const req = [], known = [], oneofs = [];
  880.     for (let field of this.fields) {
  881.       if (field.oneof) {
  882.         if (!oneofs.includes(field.oneof)) {
  883.           oneofs.push(field.oneof);
  884.           req.push(field.oneof);
  885.           known.push(field.oneof);
  886.         }
  887.       } else {
  888.         known.push(field.localName);
  889.         switch (field.kind) {
  890.           case "scalar":
  891.           case "enum":
  892.             if (!field.opt || field.repeat)
  893.               req.push(field.localName);
  894.             break;
  895.           case "message":
  896.             if (field.repeat)
  897.               req.push(field.localName);
  898.             break;
  899.           case "map":
  900.             req.push(field.localName);
  901.             break;
  902.         }
  903.       }
  904.     }
  905.     this.data = { req, known, oneofs: Object.values(oneofs) };
  906.   }
  907.   is(message, depth, allowExcessProperties = false) {
  908.     if (depth < 0)
  909.       return true;
  910.     if (message === null || message === undefined || typeof message != "object")
  911.       return false;
  912.     this.prepare();
  913.     let keys = Object.keys(message), data = this.data;
  914.     if (keys.length < data.req.length || data.req.some((n) => !keys.includes(n)))
  915.       return false;
  916.     if (!allowExcessProperties) {
  917.       if (keys.some((k) => !data.known.includes(k)))
  918.         return false;
  919.     }
  920.     if (depth < 1) {
  921.       return true;
  922.     }
  923.     for (const name of data.oneofs) {
  924.       const group = message[name];
  925.       if (!isOneofGroup(group))
  926.         return false;
  927.       if (group.oneofKind === undefined)
  928.         continue;
  929.       const field = this.fields.find((f) => f.localName === group.oneofKind);
  930.       if (!field)
  931.         return false;
  932.       if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth))
  933.         return false;
  934.     }
  935.     for (const field of this.fields) {
  936.       if (field.oneof !== undefined)
  937.         continue;
  938.       if (!this.field(message[field.localName], field, allowExcessProperties, depth))
  939.         return false;
  940.     }
  941.     return true;
  942.   }
  943.   field(arg, field, allowExcessProperties, depth) {
  944.     let repeated = field.repeat;
  945.     switch (field.kind) {
  946.       case "scalar":
  947.         if (arg === undefined)
  948.           return field.opt;
  949.         if (repeated)
  950.           return this.scalars(arg, field.T, depth, field.L);
  951.         return this.scalar(arg, field.T, field.L);
  952.       case "enum":
  953.         if (arg === undefined)
  954.           return field.opt;
  955.         if (repeated)
  956.           return this.scalars(arg, ScalarType.INT32, depth);
  957.         return this.scalar(arg, ScalarType.INT32);
  958.       case "message":
  959.         if (arg === undefined)
  960.           return true;
  961.         if (repeated)
  962.           return this.messages(arg, field.T(), allowExcessProperties, depth);
  963.         return this.message(arg, field.T(), allowExcessProperties, depth);
  964.       case "map":
  965.         if (typeof arg != "object" || arg === null)
  966.           return false;
  967.         if (depth < 2)
  968.           return true;
  969.         if (!this.mapKeys(arg, field.K, depth))
  970.           return false;
  971.         switch (field.V.kind) {
  972.           case "scalar":
  973.             return this.scalars(Object.values(arg), field.V.T, depth, field.V.L);
  974.           case "enum":
  975.             return this.scalars(Object.values(arg), ScalarType.INT32, depth);
  976.           case "message":
  977.             return this.messages(Object.values(arg), field.V.T(), allowExcessProperties, depth);
  978.         }
  979.         break;
  980.     }
  981.     return true;
  982.   }
  983.   message(arg, type, allowExcessProperties, depth) {
  984.     if (allowExcessProperties) {
  985.       return type.isAssignable(arg, depth);
  986.     }
  987.     return type.is(arg, depth);
  988.   }
  989.   messages(arg, type, allowExcessProperties, depth) {
  990.     if (!Array.isArray(arg))
  991.       return false;
  992.     if (depth < 2)
  993.       return true;
  994.     if (allowExcessProperties) {
  995.       for (let i = 0;i < arg.length && i < depth; i++)
  996.         if (!type.isAssignable(arg[i], depth - 1))
  997.           return false;
  998.     } else {
  999.       for (let i = 0;i < arg.length && i < depth; i++)
  1000.         if (!type.is(arg[i], depth - 1))
  1001.           return false;
  1002.     }
  1003.     return true;
  1004.   }
  1005.   scalar(arg, type, longType) {
  1006.     let argType = typeof arg;
  1007.     switch (type) {
  1008.       case ScalarType.UINT64:
  1009.       case ScalarType.FIXED64:
  1010.       case ScalarType.INT64:
  1011.       case ScalarType.SFIXED64:
  1012.       case ScalarType.SINT64:
  1013.         switch (longType) {
  1014.           case LongType.BIGINT:
  1015.             return argType == "bigint";
  1016.           case LongType.NUMBER:
  1017.             return argType == "number" && !isNaN(arg);
  1018.           default:
  1019.             return argType == "string";
  1020.         }
  1021.       case ScalarType.BOOL:
  1022.         return argType == "boolean";
  1023.       case ScalarType.STRING:
  1024.         return argType == "string";
  1025.       case ScalarType.BYTES:
  1026.         return arg instanceof Uint8Array;
  1027.       case ScalarType.DOUBLE:
  1028.       case ScalarType.FLOAT:
  1029.         return argType == "number" && !isNaN(arg);
  1030.       default:
  1031.         return argType == "number" && Number.isInteger(arg);
  1032.     }
  1033.   }
  1034.   scalars(arg, type, depth, longType) {
  1035.     if (!Array.isArray(arg))
  1036.       return false;
  1037.     if (depth < 2)
  1038.       return true;
  1039.     if (Array.isArray(arg)) {
  1040.       for (let i = 0;i < arg.length && i < depth; i++)
  1041.         if (!this.scalar(arg[i], type, longType))
  1042.           return false;
  1043.     }
  1044.     return true;
  1045.   }
  1046.   mapKeys(map, type, depth) {
  1047.     let keys = Object.keys(map);
  1048.     switch (type) {
  1049.       case ScalarType.INT32:
  1050.       case ScalarType.FIXED32:
  1051.       case ScalarType.SFIXED32:
  1052.       case ScalarType.SINT32:
  1053.       case ScalarType.UINT32:
  1054.         return this.scalars(keys.slice(0, depth).map((k) => parseInt(k)), type, depth);
  1055.       case ScalarType.BOOL:
  1056.         return this.scalars(keys.slice(0, depth).map((k) => k == "true" ? true : k == "false" ? false : k), type, depth);
  1057.       default:
  1058.         return this.scalars(keys, type, depth, LongType.STRING);
  1059.     }
  1060.   }
  1061. }
  1062.  
  1063. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-long-convert.js
  1064. function reflectionLongConvert(long, type) {
  1065.   switch (type) {
  1066.     case LongType.BIGINT:
  1067.       return long.toBigInt();
  1068.     case LongType.NUMBER:
  1069.       return long.toNumber();
  1070.     default:
  1071.       return long.toString();
  1072.   }
  1073. }
  1074.  
  1075. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-reader.js
  1076. class ReflectionJsonReader {
  1077.   constructor(info) {
  1078.     this.info = info;
  1079.   }
  1080.   prepare() {
  1081.     var _a;
  1082.     if (this.fMap === undefined) {
  1083.       this.fMap = {};
  1084.       const fieldsInput = (_a = this.info.fields) !== null && _a !== undefined ? _a : [];
  1085.       for (const field of fieldsInput) {
  1086.         this.fMap[field.name] = field;
  1087.         this.fMap[field.jsonName] = field;
  1088.         this.fMap[field.localName] = field;
  1089.       }
  1090.     }
  1091.   }
  1092.   assert(condition, fieldName, jsonValue) {
  1093.     if (!condition) {
  1094.       let what = typeofJsonValue(jsonValue);
  1095.       if (what == "number" || what == "boolean")
  1096.         what = jsonValue.toString();
  1097.       throw new Error(`Cannot parse JSON ${what} for ${this.info.typeName}#${fieldName}`);
  1098.     }
  1099.   }
  1100.   read(input, message, options) {
  1101.     this.prepare();
  1102.     const oneofsHandled = [];
  1103.     for (const [jsonKey, jsonValue] of Object.entries(input)) {
  1104.       const field = this.fMap[jsonKey];
  1105.       if (!field) {
  1106.         if (!options.ignoreUnknownFields)
  1107.           throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${jsonKey}`);
  1108.         continue;
  1109.       }
  1110.       const localName = field.localName;
  1111.       let target;
  1112.       if (field.oneof) {
  1113.         if (jsonValue === null && (field.kind !== "enum" || field.T()[0] !== "google.protobuf.NullValue")) {
  1114.           continue;
  1115.         }
  1116.         if (oneofsHandled.includes(field.oneof))
  1117.           throw new Error(`Multiple members of the oneof group "${field.oneof}" of ${this.info.typeName} are present in JSON.`);
  1118.         oneofsHandled.push(field.oneof);
  1119.         target = message[field.oneof] = {
  1120.           oneofKind: localName
  1121.         };
  1122.       } else {
  1123.         target = message;
  1124.       }
  1125.       if (field.kind == "map") {
  1126.         if (jsonValue === null) {
  1127.           continue;
  1128.         }
  1129.         this.assert(isJsonObject(jsonValue), field.name, jsonValue);
  1130.         const fieldObj = target[localName];
  1131.         for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) {
  1132.           this.assert(jsonObjValue !== null, field.name + " map value", null);
  1133.           let val;
  1134.           switch (field.V.kind) {
  1135.             case "message":
  1136.               val = field.V.T().internalJsonRead(jsonObjValue, options);
  1137.               break;
  1138.             case "enum":
  1139.               val = this.enum(field.V.T(), jsonObjValue, field.name, options.ignoreUnknownFields);
  1140.               if (val === false)
  1141.                 continue;
  1142.               break;
  1143.             case "scalar":
  1144.               val = this.scalar(jsonObjValue, field.V.T, field.V.L, field.name);
  1145.               break;
  1146.           }
  1147.           this.assert(val !== undefined, field.name + " map value", jsonObjValue);
  1148.           let key = jsonObjKey;
  1149.           if (field.K == ScalarType.BOOL)
  1150.             key = key == "true" ? true : key == "false" ? false : key;
  1151.           key = this.scalar(key, field.K, LongType.STRING, field.name).toString();
  1152.           fieldObj[key] = val;
  1153.         }
  1154.       } else if (field.repeat) {
  1155.         if (jsonValue === null)
  1156.           continue;
  1157.         this.assert(Array.isArray(jsonValue), field.name, jsonValue);
  1158.         const fieldArr = target[localName];
  1159.         for (const jsonItem of jsonValue) {
  1160.           this.assert(jsonItem !== null, field.name, null);
  1161.           let val;
  1162.           switch (field.kind) {
  1163.             case "message":
  1164.               val = field.T().internalJsonRead(jsonItem, options);
  1165.               break;
  1166.             case "enum":
  1167.               val = this.enum(field.T(), jsonItem, field.name, options.ignoreUnknownFields);
  1168.               if (val === false)
  1169.                 continue;
  1170.               break;
  1171.             case "scalar":
  1172.               val = this.scalar(jsonItem, field.T, field.L, field.name);
  1173.               break;
  1174.           }
  1175.           this.assert(val !== undefined, field.name, jsonValue);
  1176.           fieldArr.push(val);
  1177.         }
  1178.       } else {
  1179.         switch (field.kind) {
  1180.           case "message":
  1181.             if (jsonValue === null && field.T().typeName != "google.protobuf.Value") {
  1182.               this.assert(field.oneof === undefined, field.name + " (oneof member)", null);
  1183.               continue;
  1184.             }
  1185.             target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]);
  1186.             break;
  1187.           case "enum":
  1188.             if (jsonValue === null)
  1189.               continue;
  1190.             let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields);
  1191.             if (val === false)
  1192.               continue;
  1193.             target[localName] = val;
  1194.             break;
  1195.           case "scalar":
  1196.             if (jsonValue === null)
  1197.               continue;
  1198.             target[localName] = this.scalar(jsonValue, field.T, field.L, field.name);
  1199.             break;
  1200.         }
  1201.       }
  1202.     }
  1203.   }
  1204.   enum(type, json, fieldName, ignoreUnknownFields) {
  1205.     if (type[0] == "google.protobuf.NullValue")
  1206.       assert(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`);
  1207.     if (json === null)
  1208.       return 0;
  1209.     switch (typeof json) {
  1210.       case "number":
  1211.         assert(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`);
  1212.         return json;
  1213.       case "string":
  1214.         let localEnumName = json;
  1215.         if (type[2] && json.substring(0, type[2].length) === type[2])
  1216.           localEnumName = json.substring(type[2].length);
  1217.         let enumNumber = type[1][localEnumName];
  1218.         if (typeof enumNumber === "undefined" && ignoreUnknownFields) {
  1219.           return false;
  1220.         }
  1221.         assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`);
  1222.         return enumNumber;
  1223.     }
  1224.     assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`);
  1225.   }
  1226.   scalar(json, type, longType, fieldName) {
  1227.     let e;
  1228.     try {
  1229.       switch (type) {
  1230.         case ScalarType.DOUBLE:
  1231.         case ScalarType.FLOAT:
  1232.           if (json === null)
  1233.             return 0;
  1234.           if (json === "NaN")
  1235.             return Number.NaN;
  1236.           if (json === "Infinity")
  1237.             return Number.POSITIVE_INFINITY;
  1238.           if (json === "-Infinity")
  1239.             return Number.NEGATIVE_INFINITY;
  1240.           if (json === "") {
  1241.             e = "empty string";
  1242.             break;
  1243.           }
  1244.           if (typeof json == "string" && json.trim().length !== json.length) {
  1245.             e = "extra whitespace";
  1246.             break;
  1247.           }
  1248.           if (typeof json != "string" && typeof json != "number") {
  1249.             break;
  1250.           }
  1251.           let float = Number(json);
  1252.           if (Number.isNaN(float)) {
  1253.             e = "not a number";
  1254.             break;
  1255.           }
  1256.           if (!Number.isFinite(float)) {
  1257.             e = "too large or small";
  1258.             break;
  1259.           }
  1260.           if (type == ScalarType.FLOAT)
  1261.             assertFloat32(float);
  1262.           return float;
  1263.         case ScalarType.INT32:
  1264.         case ScalarType.FIXED32:
  1265.         case ScalarType.SFIXED32:
  1266.         case ScalarType.SINT32:
  1267.         case ScalarType.UINT32:
  1268.           if (json === null)
  1269.             return 0;
  1270.           let int32;
  1271.           if (typeof json == "number")
  1272.             int32 = json;
  1273.           else if (json === "")
  1274.             e = "empty string";
  1275.           else if (typeof json == "string") {
  1276.             if (json.trim().length !== json.length)
  1277.               e = "extra whitespace";
  1278.             else
  1279.               int32 = Number(json);
  1280.           }
  1281.           if (int32 === undefined)
  1282.             break;
  1283.           if (type == ScalarType.UINT32)
  1284.             assertUInt32(int32);
  1285.           else
  1286.             assertInt32(int32);
  1287.           return int32;
  1288.         case ScalarType.INT64:
  1289.         case ScalarType.SFIXED64:
  1290.         case ScalarType.SINT64:
  1291.           if (json === null)
  1292.             return reflectionLongConvert(PbLong.ZERO, longType);
  1293.           if (typeof json != "number" && typeof json != "string")
  1294.             break;
  1295.           return reflectionLongConvert(PbLong.from(json), longType);
  1296.         case ScalarType.FIXED64:
  1297.         case ScalarType.UINT64:
  1298.           if (json === null)
  1299.             return reflectionLongConvert(PbULong.ZERO, longType);
  1300.           if (typeof json != "number" && typeof json != "string")
  1301.             break;
  1302.           return reflectionLongConvert(PbULong.from(json), longType);
  1303.         case ScalarType.BOOL:
  1304.           if (json === null)
  1305.             return false;
  1306.           if (typeof json !== "boolean")
  1307.             break;
  1308.           return json;
  1309.         case ScalarType.STRING:
  1310.           if (json === null)
  1311.             return "";
  1312.           if (typeof json !== "string") {
  1313.             e = "extra whitespace";
  1314.             break;
  1315.           }
  1316.           try {
  1317.             encodeURIComponent(json);
  1318.           } catch (e2) {
  1319.             e2 = "invalid UTF8";
  1320.             break;
  1321.           }
  1322.           return json;
  1323.         case ScalarType.BYTES:
  1324.           if (json === null || json === "")
  1325.             return new Uint8Array(0);
  1326.           if (typeof json !== "string")
  1327.             break;
  1328.           return base64decode(json);
  1329.       }
  1330.     } catch (error) {
  1331.       e = error.message;
  1332.     }
  1333.     this.assert(false, fieldName + (e ? " - " + e : ""), json);
  1334.   }
  1335. }
  1336.  
  1337. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-json-writer.js
  1338. class ReflectionJsonWriter {
  1339.   constructor(info) {
  1340.     var _a;
  1341.     this.fields = (_a = info.fields) !== null && _a !== undefined ? _a : [];
  1342.   }
  1343.   write(message, options) {
  1344.     const json = {}, source = message;
  1345.     for (const field of this.fields) {
  1346.       if (!field.oneof) {
  1347.         let jsonValue2 = this.field(field, source[field.localName], options);
  1348.         if (jsonValue2 !== undefined)
  1349.           json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue2;
  1350.         continue;
  1351.       }
  1352.       const group = source[field.oneof];
  1353.       if (group.oneofKind !== field.localName)
  1354.         continue;
  1355.       const opt = field.kind == "scalar" || field.kind == "enum" ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options;
  1356.       let jsonValue = this.field(field, group[field.localName], opt);
  1357.       assert(jsonValue !== undefined);
  1358.       json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
  1359.     }
  1360.     return json;
  1361.   }
  1362.   field(field, value, options) {
  1363.     let jsonValue = undefined;
  1364.     if (field.kind == "map") {
  1365.       assert(typeof value == "object" && value !== null);
  1366.       const jsonObj = {};
  1367.       switch (field.V.kind) {
  1368.         case "scalar":
  1369.           for (const [entryKey, entryValue] of Object.entries(value)) {
  1370.             const val = this.scalar(field.V.T, entryValue, field.name, false, true);
  1371.             assert(val !== undefined);
  1372.             jsonObj[entryKey.toString()] = val;
  1373.           }
  1374.           break;
  1375.         case "message":
  1376.           const messageType = field.V.T();
  1377.           for (const [entryKey, entryValue] of Object.entries(value)) {
  1378.             const val = this.message(messageType, entryValue, field.name, options);
  1379.             assert(val !== undefined);
  1380.             jsonObj[entryKey.toString()] = val;
  1381.           }
  1382.           break;
  1383.         case "enum":
  1384.           const enumInfo = field.V.T();
  1385.           for (const [entryKey, entryValue] of Object.entries(value)) {
  1386.             assert(entryValue === undefined || typeof entryValue == "number");
  1387.             const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger);
  1388.             assert(val !== undefined);
  1389.             jsonObj[entryKey.toString()] = val;
  1390.           }
  1391.           break;
  1392.       }
  1393.       if (options.emitDefaultValues || Object.keys(jsonObj).length > 0)
  1394.         jsonValue = jsonObj;
  1395.     } else if (field.repeat) {
  1396.       assert(Array.isArray(value));
  1397.       const jsonArr = [];
  1398.       switch (field.kind) {
  1399.         case "scalar":
  1400.           for (let i = 0;i < value.length; i++) {
  1401.             const val = this.scalar(field.T, value[i], field.name, field.opt, true);
  1402.             assert(val !== undefined);
  1403.             jsonArr.push(val);
  1404.           }
  1405.           break;
  1406.         case "enum":
  1407.           const enumInfo = field.T();
  1408.           for (let i = 0;i < value.length; i++) {
  1409.             assert(value[i] === undefined || typeof value[i] == "number");
  1410.             const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger);
  1411.             assert(val !== undefined);
  1412.             jsonArr.push(val);
  1413.           }
  1414.           break;
  1415.         case "message":
  1416.           const messageType = field.T();
  1417.           for (let i = 0;i < value.length; i++) {
  1418.             const val = this.message(messageType, value[i], field.name, options);
  1419.             assert(val !== undefined);
  1420.             jsonArr.push(val);
  1421.           }
  1422.           break;
  1423.       }
  1424.       if (options.emitDefaultValues || jsonArr.length > 0 || options.emitDefaultValues)
  1425.         jsonValue = jsonArr;
  1426.     } else {
  1427.       switch (field.kind) {
  1428.         case "scalar":
  1429.           jsonValue = this.scalar(field.T, value, field.name, field.opt, options.emitDefaultValues);
  1430.           break;
  1431.         case "enum":
  1432.           jsonValue = this.enum(field.T(), value, field.name, field.opt, options.emitDefaultValues, options.enumAsInteger);
  1433.           break;
  1434.         case "message":
  1435.           jsonValue = this.message(field.T(), value, field.name, options);
  1436.           break;
  1437.       }
  1438.     }
  1439.     return jsonValue;
  1440.   }
  1441.   enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) {
  1442.     if (type[0] == "google.protobuf.NullValue")
  1443.       return !emitDefaultValues && !optional ? undefined : null;
  1444.     if (value === undefined) {
  1445.       assert(optional);
  1446.       return;
  1447.     }
  1448.     if (value === 0 && !emitDefaultValues && !optional)
  1449.       return;
  1450.     assert(typeof value == "number");
  1451.     assert(Number.isInteger(value));
  1452.     if (enumAsInteger || !type[1].hasOwnProperty(value))
  1453.       return value;
  1454.     if (type[2])
  1455.       return type[2] + type[1][value];
  1456.     return type[1][value];
  1457.   }
  1458.   message(type, value, fieldName, options) {
  1459.     if (value === undefined)
  1460.       return options.emitDefaultValues ? null : undefined;
  1461.     return type.internalJsonWrite(value, options);
  1462.   }
  1463.   scalar(type, value, fieldName, optional, emitDefaultValues) {
  1464.     if (value === undefined) {
  1465.       assert(optional);
  1466.       return;
  1467.     }
  1468.     const ed = emitDefaultValues || optional;
  1469.     switch (type) {
  1470.       case ScalarType.INT32:
  1471.       case ScalarType.SFIXED32:
  1472.       case ScalarType.SINT32:
  1473.         if (value === 0)
  1474.           return ed ? 0 : undefined;
  1475.         assertInt32(value);
  1476.         return value;
  1477.       case ScalarType.FIXED32:
  1478.       case ScalarType.UINT32:
  1479.         if (value === 0)
  1480.           return ed ? 0 : undefined;
  1481.         assertUInt32(value);
  1482.         return value;
  1483.       case ScalarType.FLOAT:
  1484.         assertFloat32(value);
  1485.       case ScalarType.DOUBLE:
  1486.         if (value === 0)
  1487.           return ed ? 0 : undefined;
  1488.         assert(typeof value == "number");
  1489.         if (Number.isNaN(value))
  1490.           return "NaN";
  1491.         if (value === Number.POSITIVE_INFINITY)
  1492.           return "Infinity";
  1493.         if (value === Number.NEGATIVE_INFINITY)
  1494.           return "-Infinity";
  1495.         return value;
  1496.       case ScalarType.STRING:
  1497.         if (value === "")
  1498.           return ed ? "" : undefined;
  1499.         assert(typeof value == "string");
  1500.         return value;
  1501.       case ScalarType.BOOL:
  1502.         if (value === false)
  1503.           return ed ? false : undefined;
  1504.         assert(typeof value == "boolean");
  1505.         return value;
  1506.       case ScalarType.UINT64:
  1507.       case ScalarType.FIXED64:
  1508.         assert(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
  1509.         let ulong = PbULong.from(value);
  1510.         if (ulong.isZero() && !ed)
  1511.           return;
  1512.         return ulong.toString();
  1513.       case ScalarType.INT64:
  1514.       case ScalarType.SFIXED64:
  1515.       case ScalarType.SINT64:
  1516.         assert(typeof value == "number" || typeof value == "string" || typeof value == "bigint");
  1517.         let long = PbLong.from(value);
  1518.         if (long.isZero() && !ed)
  1519.           return;
  1520.         return long.toString();
  1521.       case ScalarType.BYTES:
  1522.         assert(value instanceof Uint8Array);
  1523.         if (!value.byteLength)
  1524.           return ed ? "" : undefined;
  1525.         return base64encode(value);
  1526.     }
  1527.   }
  1528. }
  1529.  
  1530. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-scalar-default.js
  1531. function reflectionScalarDefault(type, longType = LongType.STRING) {
  1532.   switch (type) {
  1533.     case ScalarType.BOOL:
  1534.       return false;
  1535.     case ScalarType.UINT64:
  1536.     case ScalarType.FIXED64:
  1537.       return reflectionLongConvert(PbULong.ZERO, longType);
  1538.     case ScalarType.INT64:
  1539.     case ScalarType.SFIXED64:
  1540.     case ScalarType.SINT64:
  1541.       return reflectionLongConvert(PbLong.ZERO, longType);
  1542.     case ScalarType.DOUBLE:
  1543.     case ScalarType.FLOAT:
  1544.       return 0;
  1545.     case ScalarType.BYTES:
  1546.       return new Uint8Array(0);
  1547.     case ScalarType.STRING:
  1548.       return "";
  1549.     default:
  1550.       return 0;
  1551.   }
  1552. }
  1553.  
  1554. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-reader.js
  1555. class ReflectionBinaryReader {
  1556.   constructor(info) {
  1557.     this.info = info;
  1558.   }
  1559.   prepare() {
  1560.     var _a;
  1561.     if (!this.fieldNoToField) {
  1562.       const fieldsInput = (_a = this.info.fields) !== null && _a !== undefined ? _a : [];
  1563.       this.fieldNoToField = new Map(fieldsInput.map((field) => [field.no, field]));
  1564.     }
  1565.   }
  1566.   read(reader, message, options, length) {
  1567.     this.prepare();
  1568.     const end = length === undefined ? reader.len : reader.pos + length;
  1569.     while (reader.pos < end) {
  1570.       const [fieldNo, wireType] = reader.tag(), field = this.fieldNoToField.get(fieldNo);
  1571.       if (!field) {
  1572.         let u = options.readUnknownField;
  1573.         if (u == "throw")
  1574.           throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.info.typeName}`);
  1575.         let d = reader.skip(wireType);
  1576.         if (u !== false)
  1577.           (u === true ? UnknownFieldHandler.onRead : u)(this.info.typeName, message, fieldNo, wireType, d);
  1578.         continue;
  1579.       }
  1580.       let target = message, repeated = field.repeat, localName = field.localName;
  1581.       if (field.oneof) {
  1582.         target = target[field.oneof];
  1583.         if (target.oneofKind !== localName)
  1584.           target = message[field.oneof] = {
  1585.             oneofKind: localName
  1586.           };
  1587.       }
  1588.       switch (field.kind) {
  1589.         case "scalar":
  1590.         case "enum":
  1591.           let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
  1592.           let L = field.kind == "scalar" ? field.L : undefined;
  1593.           if (repeated) {
  1594.             let arr = target[localName];
  1595.             if (wireType == WireType.LengthDelimited && T != ScalarType.STRING && T != ScalarType.BYTES) {
  1596.               let e = reader.uint32() + reader.pos;
  1597.               while (reader.pos < e)
  1598.                 arr.push(this.scalar(reader, T, L));
  1599.             } else
  1600.               arr.push(this.scalar(reader, T, L));
  1601.           } else
  1602.             target[localName] = this.scalar(reader, T, L);
  1603.           break;
  1604.         case "message":
  1605.           if (repeated) {
  1606.             let arr = target[localName];
  1607.             let msg = field.T().internalBinaryRead(reader, reader.uint32(), options);
  1608.             arr.push(msg);
  1609.           } else
  1610.             target[localName] = field.T().internalBinaryRead(reader, reader.uint32(), options, target[localName]);
  1611.           break;
  1612.         case "map":
  1613.           let [mapKey, mapVal] = this.mapEntry(field, reader, options);
  1614.           target[localName][mapKey] = mapVal;
  1615.           break;
  1616.       }
  1617.     }
  1618.   }
  1619.   mapEntry(field, reader, options) {
  1620.     let length = reader.uint32();
  1621.     let end = reader.pos + length;
  1622.     let key = undefined;
  1623.     let val = undefined;
  1624.     while (reader.pos < end) {
  1625.       let [fieldNo, wireType] = reader.tag();
  1626.       switch (fieldNo) {
  1627.         case 1:
  1628.           if (field.K == ScalarType.BOOL)
  1629.             key = reader.bool().toString();
  1630.           else
  1631.             key = this.scalar(reader, field.K, LongType.STRING);
  1632.           break;
  1633.         case 2:
  1634.           switch (field.V.kind) {
  1635.             case "scalar":
  1636.               val = this.scalar(reader, field.V.T, field.V.L);
  1637.               break;
  1638.             case "enum":
  1639.               val = reader.int32();
  1640.               break;
  1641.             case "message":
  1642.               val = field.V.T().internalBinaryRead(reader, reader.uint32(), options);
  1643.               break;
  1644.           }
  1645.           break;
  1646.         default:
  1647.           throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) in map entry for ${this.info.typeName}#${field.name}`);
  1648.       }
  1649.     }
  1650.     if (key === undefined) {
  1651.       let keyRaw = reflectionScalarDefault(field.K);
  1652.       key = field.K == ScalarType.BOOL ? keyRaw.toString() : keyRaw;
  1653.     }
  1654.     if (val === undefined)
  1655.       switch (field.V.kind) {
  1656.         case "scalar":
  1657.           val = reflectionScalarDefault(field.V.T, field.V.L);
  1658.           break;
  1659.         case "enum":
  1660.           val = 0;
  1661.           break;
  1662.         case "message":
  1663.           val = field.V.T().create();
  1664.           break;
  1665.       }
  1666.     return [key, val];
  1667.   }
  1668.   scalar(reader, type, longType) {
  1669.     switch (type) {
  1670.       case ScalarType.INT32:
  1671.         return reader.int32();
  1672.       case ScalarType.STRING:
  1673.         return reader.string();
  1674.       case ScalarType.BOOL:
  1675.         return reader.bool();
  1676.       case ScalarType.DOUBLE:
  1677.         return reader.double();
  1678.       case ScalarType.FLOAT:
  1679.         return reader.float();
  1680.       case ScalarType.INT64:
  1681.         return reflectionLongConvert(reader.int64(), longType);
  1682.       case ScalarType.UINT64:
  1683.         return reflectionLongConvert(reader.uint64(), longType);
  1684.       case ScalarType.FIXED64:
  1685.         return reflectionLongConvert(reader.fixed64(), longType);
  1686.       case ScalarType.FIXED32:
  1687.         return reader.fixed32();
  1688.       case ScalarType.BYTES:
  1689.         return reader.bytes();
  1690.       case ScalarType.UINT32:
  1691.         return reader.uint32();
  1692.       case ScalarType.SFIXED32:
  1693.         return reader.sfixed32();
  1694.       case ScalarType.SFIXED64:
  1695.         return reflectionLongConvert(reader.sfixed64(), longType);
  1696.       case ScalarType.SINT32:
  1697.         return reader.sint32();
  1698.       case ScalarType.SINT64:
  1699.         return reflectionLongConvert(reader.sint64(), longType);
  1700.     }
  1701.   }
  1702. }
  1703.  
  1704. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-binary-writer.js
  1705. class ReflectionBinaryWriter {
  1706.   constructor(info) {
  1707.     this.info = info;
  1708.   }
  1709.   prepare() {
  1710.     if (!this.fields) {
  1711.       const fieldsInput = this.info.fields ? this.info.fields.concat() : [];
  1712.       this.fields = fieldsInput.sort((a, b) => a.no - b.no);
  1713.     }
  1714.   }
  1715.   write(message, writer, options) {
  1716.     this.prepare();
  1717.     for (const field of this.fields) {
  1718.       let value, emitDefault, repeated = field.repeat, localName = field.localName;
  1719.       if (field.oneof) {
  1720.         const group = message[field.oneof];
  1721.         if (group.oneofKind !== localName)
  1722.           continue;
  1723.         value = group[localName];
  1724.         emitDefault = true;
  1725.       } else {
  1726.         value = message[localName];
  1727.         emitDefault = false;
  1728.       }
  1729.       switch (field.kind) {
  1730.         case "scalar":
  1731.         case "enum":
  1732.           let T = field.kind == "enum" ? ScalarType.INT32 : field.T;
  1733.           if (repeated) {
  1734.             assert(Array.isArray(value));
  1735.             if (repeated == RepeatType.PACKED)
  1736.               this.packed(writer, T, field.no, value);
  1737.             else
  1738.               for (const item of value)
  1739.                 this.scalar(writer, T, field.no, item, true);
  1740.           } else if (value === undefined)
  1741.             assert(field.opt);
  1742.           else
  1743.             this.scalar(writer, T, field.no, value, emitDefault || field.opt);
  1744.           break;
  1745.         case "message":
  1746.           if (repeated) {
  1747.             assert(Array.isArray(value));
  1748.             for (const item of value)
  1749.               this.message(writer, options, field.T(), field.no, item);
  1750.           } else {
  1751.             this.message(writer, options, field.T(), field.no, value);
  1752.           }
  1753.           break;
  1754.         case "map":
  1755.           assert(typeof value == "object" && value !== null);
  1756.           for (const [key, val] of Object.entries(value))
  1757.             this.mapEntry(writer, options, field, key, val);
  1758.           break;
  1759.       }
  1760.     }
  1761.     let u = options.writeUnknownFields;
  1762.     if (u !== false)
  1763.       (u === true ? UnknownFieldHandler.onWrite : u)(this.info.typeName, message, writer);
  1764.   }
  1765.   mapEntry(writer, options, field, key, value) {
  1766.     writer.tag(field.no, WireType.LengthDelimited);
  1767.     writer.fork();
  1768.     let keyValue = key;
  1769.     switch (field.K) {
  1770.       case ScalarType.INT32:
  1771.       case ScalarType.FIXED32:
  1772.       case ScalarType.UINT32:
  1773.       case ScalarType.SFIXED32:
  1774.       case ScalarType.SINT32:
  1775.         keyValue = Number.parseInt(key);
  1776.         break;
  1777.       case ScalarType.BOOL:
  1778.         assert(key == "true" || key == "false");
  1779.         keyValue = key == "true";
  1780.         break;
  1781.     }
  1782.     this.scalar(writer, field.K, 1, keyValue, true);
  1783.     switch (field.V.kind) {
  1784.       case "scalar":
  1785.         this.scalar(writer, field.V.T, 2, value, true);
  1786.         break;
  1787.       case "enum":
  1788.         this.scalar(writer, ScalarType.INT32, 2, value, true);
  1789.         break;
  1790.       case "message":
  1791.         this.message(writer, options, field.V.T(), 2, value);
  1792.         break;
  1793.     }
  1794.     writer.join();
  1795.   }
  1796.   message(writer, options, handler, fieldNo, value) {
  1797.     if (value === undefined)
  1798.       return;
  1799.     handler.internalBinaryWrite(value, writer.tag(fieldNo, WireType.LengthDelimited).fork(), options);
  1800.     writer.join();
  1801.   }
  1802.   scalar(writer, type, fieldNo, value, emitDefault) {
  1803.     let [wireType, method, isDefault] = this.scalarInfo(type, value);
  1804.     if (!isDefault || emitDefault) {
  1805.       writer.tag(fieldNo, wireType);
  1806.       writer[method](value);
  1807.     }
  1808.   }
  1809.   packed(writer, type, fieldNo, value) {
  1810.     if (!value.length)
  1811.       return;
  1812.     assert(type !== ScalarType.BYTES && type !== ScalarType.STRING);
  1813.     writer.tag(fieldNo, WireType.LengthDelimited);
  1814.     writer.fork();
  1815.     let [, method] = this.scalarInfo(type);
  1816.     for (let i = 0;i < value.length; i++)
  1817.       writer[method](value[i]);
  1818.     writer.join();
  1819.   }
  1820.   scalarInfo(type, value) {
  1821.     let t = WireType.Varint;
  1822.     let m;
  1823.     let i = value === undefined;
  1824.     let d = value === 0;
  1825.     switch (type) {
  1826.       case ScalarType.INT32:
  1827.         m = "int32";
  1828.         break;
  1829.       case ScalarType.STRING:
  1830.         d = i || !value.length;
  1831.         t = WireType.LengthDelimited;
  1832.         m = "string";
  1833.         break;
  1834.       case ScalarType.BOOL:
  1835.         d = value === false;
  1836.         m = "bool";
  1837.         break;
  1838.       case ScalarType.UINT32:
  1839.         m = "uint32";
  1840.         break;
  1841.       case ScalarType.DOUBLE:
  1842.         t = WireType.Bit64;
  1843.         m = "double";
  1844.         break;
  1845.       case ScalarType.FLOAT:
  1846.         t = WireType.Bit32;
  1847.         m = "float";
  1848.         break;
  1849.       case ScalarType.INT64:
  1850.         d = i || PbLong.from(value).isZero();
  1851.         m = "int64";
  1852.         break;
  1853.       case ScalarType.UINT64:
  1854.         d = i || PbULong.from(value).isZero();
  1855.         m = "uint64";
  1856.         break;
  1857.       case ScalarType.FIXED64:
  1858.         d = i || PbULong.from(value).isZero();
  1859.         t = WireType.Bit64;
  1860.         m = "fixed64";
  1861.         break;
  1862.       case ScalarType.BYTES:
  1863.         d = i || !value.byteLength;
  1864.         t = WireType.LengthDelimited;
  1865.         m = "bytes";
  1866.         break;
  1867.       case ScalarType.FIXED32:
  1868.         t = WireType.Bit32;
  1869.         m = "fixed32";
  1870.         break;
  1871.       case ScalarType.SFIXED32:
  1872.         t = WireType.Bit32;
  1873.         m = "sfixed32";
  1874.         break;
  1875.       case ScalarType.SFIXED64:
  1876.         d = i || PbLong.from(value).isZero();
  1877.         t = WireType.Bit64;
  1878.         m = "sfixed64";
  1879.         break;
  1880.       case ScalarType.SINT32:
  1881.         m = "sint32";
  1882.         break;
  1883.       case ScalarType.SINT64:
  1884.         d = i || PbLong.from(value).isZero();
  1885.         m = "sint64";
  1886.         break;
  1887.     }
  1888.     return [t, m, i || d];
  1889.   }
  1890. }
  1891.  
  1892. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-create.js
  1893. function reflectionCreate(type) {
  1894.   const msg = type.messagePrototype ? Object.create(type.messagePrototype) : Object.defineProperty({}, MESSAGE_TYPE, { value: type });
  1895.   for (let field of type.fields) {
  1896.     let name = field.localName;
  1897.     if (field.opt)
  1898.       continue;
  1899.     if (field.oneof)
  1900.       msg[field.oneof] = { oneofKind: undefined };
  1901.     else if (field.repeat)
  1902.       msg[name] = [];
  1903.     else
  1904.       switch (field.kind) {
  1905.         case "scalar":
  1906.           msg[name] = reflectionScalarDefault(field.T, field.L);
  1907.           break;
  1908.         case "enum":
  1909.           msg[name] = 0;
  1910.           break;
  1911.         case "map":
  1912.           msg[name] = {};
  1913.           break;
  1914.       }
  1915.   }
  1916.   return msg;
  1917. }
  1918.  
  1919. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-merge-partial.js
  1920. function reflectionMergePartial(info, target, source) {
  1921.   let fieldValue, input = source, output;
  1922.   for (let field of info.fields) {
  1923.     let name = field.localName;
  1924.     if (field.oneof) {
  1925.       const group = input[field.oneof];
  1926.       if ((group === null || group === undefined ? undefined : group.oneofKind) == undefined) {
  1927.         continue;
  1928.       }
  1929.       fieldValue = group[name];
  1930.       output = target[field.oneof];
  1931.       output.oneofKind = group.oneofKind;
  1932.       if (fieldValue == undefined) {
  1933.         delete output[name];
  1934.         continue;
  1935.       }
  1936.     } else {
  1937.       fieldValue = input[name];
  1938.       output = target;
  1939.       if (fieldValue == undefined) {
  1940.         continue;
  1941.       }
  1942.     }
  1943.     if (field.repeat)
  1944.       output[name].length = fieldValue.length;
  1945.     switch (field.kind) {
  1946.       case "scalar":
  1947.       case "enum":
  1948.         if (field.repeat)
  1949.           for (let i = 0;i < fieldValue.length; i++)
  1950.             output[name][i] = fieldValue[i];
  1951.         else
  1952.           output[name] = fieldValue;
  1953.         break;
  1954.       case "message":
  1955.         let T = field.T();
  1956.         if (field.repeat)
  1957.           for (let i = 0;i < fieldValue.length; i++)
  1958.             output[name][i] = T.create(fieldValue[i]);
  1959.         else if (output[name] === undefined)
  1960.           output[name] = T.create(fieldValue);
  1961.         else
  1962.           T.mergePartial(output[name], fieldValue);
  1963.         break;
  1964.       case "map":
  1965.         switch (field.V.kind) {
  1966.           case "scalar":
  1967.           case "enum":
  1968.             Object.assign(output[name], fieldValue);
  1969.             break;
  1970.           case "message":
  1971.             let T2 = field.V.T();
  1972.             for (let k of Object.keys(fieldValue))
  1973.               output[name][k] = T2.create(fieldValue[k]);
  1974.             break;
  1975.         }
  1976.         break;
  1977.     }
  1978.   }
  1979. }
  1980.  
  1981. // node_modules/@protobuf-ts/runtime/build/es2015/reflection-equals.js
  1982. function reflectionEquals(info, a, b) {
  1983.   if (a === b)
  1984.     return true;
  1985.   if (!a || !b)
  1986.     return false;
  1987.   for (let field of info.fields) {
  1988.     let localName = field.localName;
  1989.     let val_a = field.oneof ? a[field.oneof][localName] : a[localName];
  1990.     let val_b = field.oneof ? b[field.oneof][localName] : b[localName];
  1991.     switch (field.kind) {
  1992.       case "enum":
  1993.       case "scalar":
  1994.         let t = field.kind == "enum" ? ScalarType.INT32 : field.T;
  1995.         if (!(field.repeat ? repeatedPrimitiveEq(t, val_a, val_b) : primitiveEq(t, val_a, val_b)))
  1996.           return false;
  1997.         break;
  1998.       case "map":
  1999.         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))))
  2000.           return false;
  2001.         break;
  2002.       case "message":
  2003.         let T = field.T();
  2004.         if (!(field.repeat ? repeatedMsgEq(T, val_a, val_b) : T.equals(val_a, val_b)))
  2005.           return false;
  2006.         break;
  2007.     }
  2008.   }
  2009.   return true;
  2010. }
  2011. var objectValues = Object.values;
  2012. function primitiveEq(type, a, b) {
  2013.   if (a === b)
  2014.     return true;
  2015.   if (type !== ScalarType.BYTES)
  2016.     return false;
  2017.   let ba = a;
  2018.   let bb = b;
  2019.   if (ba.length !== bb.length)
  2020.     return false;
  2021.   for (let i = 0;i < ba.length; i++)
  2022.     if (ba[i] != bb[i])
  2023.       return false;
  2024.   return true;
  2025. }
  2026. function repeatedPrimitiveEq(type, a, b) {
  2027.   if (a.length !== b.length)
  2028.     return false;
  2029.   for (let i = 0;i < a.length; i++)
  2030.     if (!primitiveEq(type, a[i], b[i]))
  2031.       return false;
  2032.   return true;
  2033. }
  2034. function repeatedMsgEq(type, a, b) {
  2035.   if (a.length !== b.length)
  2036.     return false;
  2037.   for (let i = 0;i < a.length; i++)
  2038.     if (!type.equals(a[i], b[i]))
  2039.       return false;
  2040.   return true;
  2041. }
  2042.  
  2043. // node_modules/@protobuf-ts/runtime/build/es2015/message-type.js
  2044. var baseDescriptors = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({}));
  2045.  
  2046. class MessageType {
  2047.   constructor(name, fields, options) {
  2048.     this.defaultCheckDepth = 16;
  2049.     this.typeName = name;
  2050.     this.fields = fields.map(normalizeFieldInfo);
  2051.     this.options = options !== null && options !== undefined ? options : {};
  2052.     this.messagePrototype = Object.create(null, Object.assign(Object.assign({}, baseDescriptors), { [MESSAGE_TYPE]: { value: this } }));
  2053.     this.refTypeCheck = new ReflectionTypeCheck(this);
  2054.     this.refJsonReader = new ReflectionJsonReader(this);
  2055.     this.refJsonWriter = new ReflectionJsonWriter(this);
  2056.     this.refBinReader = new ReflectionBinaryReader(this);
  2057.     this.refBinWriter = new ReflectionBinaryWriter(this);
  2058.   }
  2059.   create(value) {
  2060.     let message = reflectionCreate(this);
  2061.     if (value !== undefined) {
  2062.       reflectionMergePartial(this, message, value);
  2063.     }
  2064.     return message;
  2065.   }
  2066.   clone(message) {
  2067.     let copy = this.create();
  2068.     reflectionMergePartial(this, copy, message);
  2069.     return copy;
  2070.   }
  2071.   equals(a, b) {
  2072.     return reflectionEquals(this, a, b);
  2073.   }
  2074.   is(arg, depth = this.defaultCheckDepth) {
  2075.     return this.refTypeCheck.is(arg, depth, false);
  2076.   }
  2077.   isAssignable(arg, depth = this.defaultCheckDepth) {
  2078.     return this.refTypeCheck.is(arg, depth, true);
  2079.   }
  2080.   mergePartial(target, source) {
  2081.     reflectionMergePartial(this, target, source);
  2082.   }
  2083.   fromBinary(data, options) {
  2084.     let opt = binaryReadOptions(options);
  2085.     return this.internalBinaryRead(opt.readerFactory(data), data.byteLength, opt);
  2086.   }
  2087.   fromJson(json, options) {
  2088.     return this.internalJsonRead(json, jsonReadOptions(options));
  2089.   }
  2090.   fromJsonString(json, options) {
  2091.     let value = JSON.parse(json);
  2092.     return this.fromJson(value, options);
  2093.   }
  2094.   toJson(message, options) {
  2095.     return this.internalJsonWrite(message, jsonWriteOptions(options));
  2096.   }
  2097.   toJsonString(message, options) {
  2098.     var _a;
  2099.     let value = this.toJson(message, options);
  2100.     return JSON.stringify(value, null, (_a = options === null || options === undefined ? undefined : options.prettySpaces) !== null && _a !== undefined ? _a : 0);
  2101.   }
  2102.   toBinary(message, options) {
  2103.     let opt = binaryWriteOptions(options);
  2104.     return this.internalBinaryWrite(message, opt.writerFactory(), opt).finish();
  2105.   }
  2106.   internalJsonRead(json, options, target) {
  2107.     if (json !== null && typeof json == "object" && !Array.isArray(json)) {
  2108.       let message = target !== null && target !== undefined ? target : this.create();
  2109.       this.refJsonReader.read(json, message, options);
  2110.       return message;
  2111.     }
  2112.     throw new Error(`Unable to parse message ${this.typeName} from JSON ${typeofJsonValue(json)}.`);
  2113.   }
  2114.   internalJsonWrite(message, options) {
  2115.     return this.refJsonWriter.write(message, options);
  2116.   }
  2117.   internalBinaryWrite(message, writer, options) {
  2118.     this.refBinWriter.write(message, writer, options);
  2119.     return writer;
  2120.   }
  2121.   internalBinaryRead(reader, length, options, target) {
  2122.     let message = target !== null && target !== undefined ? target : this.create();
  2123.     this.refBinReader.read(reader, message, options, length);
  2124.     return message;
  2125.   }
  2126. }
  2127. // node_modules/discord-protos/src/discord_protos/google/protobuf/wrappers.ts
  2128. class DoubleValue$Type extends MessageType {
  2129.   constructor() {
  2130.     super("google.protobuf.DoubleValue", [
  2131.       { no: 1, name: "value", kind: "scalar", T: 1 }
  2132.     ]);
  2133.   }
  2134.   internalJsonWrite(message, options) {
  2135.     return this.refJsonWriter.scalar(2, message.value, "value", false, true);
  2136.   }
  2137.   internalJsonRead(json, options, target) {
  2138.     if (!target)
  2139.       target = this.create();
  2140.     target.value = this.refJsonReader.scalar(json, 1, undefined, "value");
  2141.     return target;
  2142.   }
  2143.   create(value) {
  2144.     const message = globalThis.Object.create(this.messagePrototype);
  2145.     message.value = 0;
  2146.     if (value !== undefined)
  2147.       reflectionMergePartial(this, message, value);
  2148.     return message;
  2149.   }
  2150.   internalBinaryRead(reader, length, options, target) {
  2151.     let message = target ?? this.create(), end = reader.pos + length;
  2152.     while (reader.pos < end) {
  2153.       let [fieldNo, wireType] = reader.tag();
  2154.       switch (fieldNo) {
  2155.         case 1:
  2156.           message.value = reader.double();
  2157.           break;
  2158.         default:
  2159.           let u = options.readUnknownField;
  2160.           if (u === "throw")
  2161.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2162.           let d = reader.skip(wireType);
  2163.           if (u !== false)
  2164.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2165.       }
  2166.     }
  2167.     return message;
  2168.   }
  2169.   internalBinaryWrite(message, writer, options) {
  2170.     if (message.value !== 0)
  2171.       writer.tag(1, WireType.Bit64).double(message.value);
  2172.     let u = options.writeUnknownFields;
  2173.     if (u !== false)
  2174.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2175.     return writer;
  2176.   }
  2177. }
  2178. var DoubleValue = new DoubleValue$Type;
  2179.  
  2180. class FloatValue$Type extends MessageType {
  2181.   constructor() {
  2182.     super("google.protobuf.FloatValue", [
  2183.       { no: 1, name: "value", kind: "scalar", T: 2 }
  2184.     ]);
  2185.   }
  2186.   internalJsonWrite(message, options) {
  2187.     return this.refJsonWriter.scalar(1, message.value, "value", false, true);
  2188.   }
  2189.   internalJsonRead(json, options, target) {
  2190.     if (!target)
  2191.       target = this.create();
  2192.     target.value = this.refJsonReader.scalar(json, 1, undefined, "value");
  2193.     return target;
  2194.   }
  2195.   create(value) {
  2196.     const message = globalThis.Object.create(this.messagePrototype);
  2197.     message.value = 0;
  2198.     if (value !== undefined)
  2199.       reflectionMergePartial(this, message, value);
  2200.     return message;
  2201.   }
  2202.   internalBinaryRead(reader, length, options, target) {
  2203.     let message = target ?? this.create(), end = reader.pos + length;
  2204.     while (reader.pos < end) {
  2205.       let [fieldNo, wireType] = reader.tag();
  2206.       switch (fieldNo) {
  2207.         case 1:
  2208.           message.value = reader.float();
  2209.           break;
  2210.         default:
  2211.           let u = options.readUnknownField;
  2212.           if (u === "throw")
  2213.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2214.           let d = reader.skip(wireType);
  2215.           if (u !== false)
  2216.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2217.       }
  2218.     }
  2219.     return message;
  2220.   }
  2221.   internalBinaryWrite(message, writer, options) {
  2222.     if (message.value !== 0)
  2223.       writer.tag(1, WireType.Bit32).float(message.value);
  2224.     let u = options.writeUnknownFields;
  2225.     if (u !== false)
  2226.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2227.     return writer;
  2228.   }
  2229. }
  2230. var FloatValue = new FloatValue$Type;
  2231.  
  2232. class Int64Value$Type extends MessageType {
  2233.   constructor() {
  2234.     super("google.protobuf.Int64Value", [
  2235.       { no: 1, name: "value", kind: "scalar", T: 3, L: 0 }
  2236.     ]);
  2237.   }
  2238.   internalJsonWrite(message, options) {
  2239.     return this.refJsonWriter.scalar(ScalarType.INT64, message.value, "value", false, true);
  2240.   }
  2241.   internalJsonRead(json, options, target) {
  2242.     if (!target)
  2243.       target = this.create();
  2244.     target.value = this.refJsonReader.scalar(json, ScalarType.INT64, LongType.BIGINT, "value");
  2245.     return target;
  2246.   }
  2247.   create(value) {
  2248.     const message = globalThis.Object.create(this.messagePrototype);
  2249.     message.value = 0n;
  2250.     if (value !== undefined)
  2251.       reflectionMergePartial(this, message, value);
  2252.     return message;
  2253.   }
  2254.   internalBinaryRead(reader, length, options, target) {
  2255.     let message = target ?? this.create(), end = reader.pos + length;
  2256.     while (reader.pos < end) {
  2257.       let [fieldNo, wireType] = reader.tag();
  2258.       switch (fieldNo) {
  2259.         case 1:
  2260.           message.value = reader.int64().toBigInt();
  2261.           break;
  2262.         default:
  2263.           let u = options.readUnknownField;
  2264.           if (u === "throw")
  2265.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2266.           let d = reader.skip(wireType);
  2267.           if (u !== false)
  2268.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2269.       }
  2270.     }
  2271.     return message;
  2272.   }
  2273.   internalBinaryWrite(message, writer, options) {
  2274.     if (message.value !== 0n)
  2275.       writer.tag(1, WireType.Varint).int64(message.value);
  2276.     let u = options.writeUnknownFields;
  2277.     if (u !== false)
  2278.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2279.     return writer;
  2280.   }
  2281. }
  2282. var Int64Value = new Int64Value$Type;
  2283.  
  2284. class UInt64Value$Type extends MessageType {
  2285.   constructor() {
  2286.     super("google.protobuf.UInt64Value", [
  2287.       { no: 1, name: "value", kind: "scalar", T: 4, L: 0 }
  2288.     ]);
  2289.   }
  2290.   internalJsonWrite(message, options) {
  2291.     return this.refJsonWriter.scalar(ScalarType.UINT64, message.value, "value", false, true);
  2292.   }
  2293.   internalJsonRead(json, options, target) {
  2294.     if (!target)
  2295.       target = this.create();
  2296.     target.value = this.refJsonReader.scalar(json, ScalarType.UINT64, LongType.BIGINT, "value");
  2297.     return target;
  2298.   }
  2299.   create(value) {
  2300.     const message = globalThis.Object.create(this.messagePrototype);
  2301.     message.value = 0n;
  2302.     if (value !== undefined)
  2303.       reflectionMergePartial(this, message, value);
  2304.     return message;
  2305.   }
  2306.   internalBinaryRead(reader, length, options, target) {
  2307.     let message = target ?? this.create(), end = reader.pos + length;
  2308.     while (reader.pos < end) {
  2309.       let [fieldNo, wireType] = reader.tag();
  2310.       switch (fieldNo) {
  2311.         case 1:
  2312.           message.value = reader.uint64().toBigInt();
  2313.           break;
  2314.         default:
  2315.           let u = options.readUnknownField;
  2316.           if (u === "throw")
  2317.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2318.           let d = reader.skip(wireType);
  2319.           if (u !== false)
  2320.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2321.       }
  2322.     }
  2323.     return message;
  2324.   }
  2325.   internalBinaryWrite(message, writer, options) {
  2326.     if (message.value !== 0n)
  2327.       writer.tag(1, WireType.Varint).uint64(message.value);
  2328.     let u = options.writeUnknownFields;
  2329.     if (u !== false)
  2330.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2331.     return writer;
  2332.   }
  2333. }
  2334. var UInt64Value = new UInt64Value$Type;
  2335.  
  2336. class Int32Value$Type extends MessageType {
  2337.   constructor() {
  2338.     super("google.protobuf.Int32Value", [
  2339.       { no: 1, name: "value", kind: "scalar", T: 5 }
  2340.     ]);
  2341.   }
  2342.   internalJsonWrite(message, options) {
  2343.     return this.refJsonWriter.scalar(5, message.value, "value", false, true);
  2344.   }
  2345.   internalJsonRead(json, options, target) {
  2346.     if (!target)
  2347.       target = this.create();
  2348.     target.value = this.refJsonReader.scalar(json, 5, undefined, "value");
  2349.     return target;
  2350.   }
  2351.   create(value) {
  2352.     const message = globalThis.Object.create(this.messagePrototype);
  2353.     message.value = 0;
  2354.     if (value !== undefined)
  2355.       reflectionMergePartial(this, message, value);
  2356.     return message;
  2357.   }
  2358.   internalBinaryRead(reader, length, options, target) {
  2359.     let message = target ?? this.create(), end = reader.pos + length;
  2360.     while (reader.pos < end) {
  2361.       let [fieldNo, wireType] = reader.tag();
  2362.       switch (fieldNo) {
  2363.         case 1:
  2364.           message.value = reader.int32();
  2365.           break;
  2366.         default:
  2367.           let u = options.readUnknownField;
  2368.           if (u === "throw")
  2369.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2370.           let d = reader.skip(wireType);
  2371.           if (u !== false)
  2372.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2373.       }
  2374.     }
  2375.     return message;
  2376.   }
  2377.   internalBinaryWrite(message, writer, options) {
  2378.     if (message.value !== 0)
  2379.       writer.tag(1, WireType.Varint).int32(message.value);
  2380.     let u = options.writeUnknownFields;
  2381.     if (u !== false)
  2382.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2383.     return writer;
  2384.   }
  2385. }
  2386. var Int32Value = new Int32Value$Type;
  2387.  
  2388. class UInt32Value$Type extends MessageType {
  2389.   constructor() {
  2390.     super("google.protobuf.UInt32Value", [
  2391.       { no: 1, name: "value", kind: "scalar", T: 13 }
  2392.     ]);
  2393.   }
  2394.   internalJsonWrite(message, options) {
  2395.     return this.refJsonWriter.scalar(13, message.value, "value", false, true);
  2396.   }
  2397.   internalJsonRead(json, options, target) {
  2398.     if (!target)
  2399.       target = this.create();
  2400.     target.value = this.refJsonReader.scalar(json, 13, undefined, "value");
  2401.     return target;
  2402.   }
  2403.   create(value) {
  2404.     const message = globalThis.Object.create(this.messagePrototype);
  2405.     message.value = 0;
  2406.     if (value !== undefined)
  2407.       reflectionMergePartial(this, message, value);
  2408.     return message;
  2409.   }
  2410.   internalBinaryRead(reader, length, options, target) {
  2411.     let message = target ?? this.create(), end = reader.pos + length;
  2412.     while (reader.pos < end) {
  2413.       let [fieldNo, wireType] = reader.tag();
  2414.       switch (fieldNo) {
  2415.         case 1:
  2416.           message.value = reader.uint32();
  2417.           break;
  2418.         default:
  2419.           let u = options.readUnknownField;
  2420.           if (u === "throw")
  2421.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2422.           let d = reader.skip(wireType);
  2423.           if (u !== false)
  2424.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2425.       }
  2426.     }
  2427.     return message;
  2428.   }
  2429.   internalBinaryWrite(message, writer, options) {
  2430.     if (message.value !== 0)
  2431.       writer.tag(1, WireType.Varint).uint32(message.value);
  2432.     let u = options.writeUnknownFields;
  2433.     if (u !== false)
  2434.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2435.     return writer;
  2436.   }
  2437. }
  2438. var UInt32Value = new UInt32Value$Type;
  2439.  
  2440. class BoolValue$Type extends MessageType {
  2441.   constructor() {
  2442.     super("google.protobuf.BoolValue", [
  2443.       { no: 1, name: "value", kind: "scalar", T: 8 }
  2444.     ]);
  2445.   }
  2446.   internalJsonWrite(message, options) {
  2447.     return message.value;
  2448.   }
  2449.   internalJsonRead(json, options, target) {
  2450.     if (!target)
  2451.       target = this.create();
  2452.     target.value = this.refJsonReader.scalar(json, 8, undefined, "value");
  2453.     return target;
  2454.   }
  2455.   create(value) {
  2456.     const message = globalThis.Object.create(this.messagePrototype);
  2457.     message.value = false;
  2458.     if (value !== undefined)
  2459.       reflectionMergePartial(this, message, value);
  2460.     return message;
  2461.   }
  2462.   internalBinaryRead(reader, length, options, target) {
  2463.     let message = target ?? this.create(), end = reader.pos + length;
  2464.     while (reader.pos < end) {
  2465.       let [fieldNo, wireType] = reader.tag();
  2466.       switch (fieldNo) {
  2467.         case 1:
  2468.           message.value = reader.bool();
  2469.           break;
  2470.         default:
  2471.           let u = options.readUnknownField;
  2472.           if (u === "throw")
  2473.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2474.           let d = reader.skip(wireType);
  2475.           if (u !== false)
  2476.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2477.       }
  2478.     }
  2479.     return message;
  2480.   }
  2481.   internalBinaryWrite(message, writer, options) {
  2482.     if (message.value !== false)
  2483.       writer.tag(1, WireType.Varint).bool(message.value);
  2484.     let u = options.writeUnknownFields;
  2485.     if (u !== false)
  2486.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2487.     return writer;
  2488.   }
  2489. }
  2490. var BoolValue = new BoolValue$Type;
  2491.  
  2492. class StringValue$Type extends MessageType {
  2493.   constructor() {
  2494.     super("google.protobuf.StringValue", [
  2495.       { no: 1, name: "value", kind: "scalar", T: 9 }
  2496.     ]);
  2497.   }
  2498.   internalJsonWrite(message, options) {
  2499.     return message.value;
  2500.   }
  2501.   internalJsonRead(json, options, target) {
  2502.     if (!target)
  2503.       target = this.create();
  2504.     target.value = this.refJsonReader.scalar(json, 9, undefined, "value");
  2505.     return target;
  2506.   }
  2507.   create(value) {
  2508.     const message = globalThis.Object.create(this.messagePrototype);
  2509.     message.value = "";
  2510.     if (value !== undefined)
  2511.       reflectionMergePartial(this, message, value);
  2512.     return message;
  2513.   }
  2514.   internalBinaryRead(reader, length, options, target) {
  2515.     let message = target ?? this.create(), end = reader.pos + length;
  2516.     while (reader.pos < end) {
  2517.       let [fieldNo, wireType] = reader.tag();
  2518.       switch (fieldNo) {
  2519.         case 1:
  2520.           message.value = reader.string();
  2521.           break;
  2522.         default:
  2523.           let u = options.readUnknownField;
  2524.           if (u === "throw")
  2525.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2526.           let d = reader.skip(wireType);
  2527.           if (u !== false)
  2528.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2529.       }
  2530.     }
  2531.     return message;
  2532.   }
  2533.   internalBinaryWrite(message, writer, options) {
  2534.     if (message.value !== "")
  2535.       writer.tag(1, WireType.LengthDelimited).string(message.value);
  2536.     let u = options.writeUnknownFields;
  2537.     if (u !== false)
  2538.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2539.     return writer;
  2540.   }
  2541. }
  2542. var StringValue = new StringValue$Type;
  2543.  
  2544. class BytesValue$Type extends MessageType {
  2545.   constructor() {
  2546.     super("google.protobuf.BytesValue", [
  2547.       { no: 1, name: "value", kind: "scalar", T: 12 }
  2548.     ]);
  2549.   }
  2550.   internalJsonWrite(message, options) {
  2551.     return this.refJsonWriter.scalar(12, message.value, "value", false, true);
  2552.   }
  2553.   internalJsonRead(json, options, target) {
  2554.     if (!target)
  2555.       target = this.create();
  2556.     target.value = this.refJsonReader.scalar(json, 12, undefined, "value");
  2557.     return target;
  2558.   }
  2559.   create(value) {
  2560.     const message = globalThis.Object.create(this.messagePrototype);
  2561.     message.value = new Uint8Array(0);
  2562.     if (value !== undefined)
  2563.       reflectionMergePartial(this, message, value);
  2564.     return message;
  2565.   }
  2566.   internalBinaryRead(reader, length, options, target) {
  2567.     let message = target ?? this.create(), end = reader.pos + length;
  2568.     while (reader.pos < end) {
  2569.       let [fieldNo, wireType] = reader.tag();
  2570.       switch (fieldNo) {
  2571.         case 1:
  2572.           message.value = reader.bytes();
  2573.           break;
  2574.         default:
  2575.           let u = options.readUnknownField;
  2576.           if (u === "throw")
  2577.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2578.           let d = reader.skip(wireType);
  2579.           if (u !== false)
  2580.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2581.       }
  2582.     }
  2583.     return message;
  2584.   }
  2585.   internalBinaryWrite(message, writer, options) {
  2586.     if (message.value.length)
  2587.       writer.tag(1, WireType.LengthDelimited).bytes(message.value);
  2588.     let u = options.writeUnknownFields;
  2589.     if (u !== false)
  2590.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2591.     return writer;
  2592.   }
  2593. }
  2594. var BytesValue = new BytesValue$Type;
  2595.  
  2596. // node_modules/discord-protos/src/discord_protos/google/protobuf/timestamp.ts
  2597. class Timestamp$Type extends MessageType {
  2598.   constructor() {
  2599.     super("google.protobuf.Timestamp", [
  2600.       { no: 1, name: "seconds", kind: "scalar", T: 3, L: 0 },
  2601.       { no: 2, name: "nanos", kind: "scalar", T: 5 }
  2602.     ]);
  2603.   }
  2604.   now() {
  2605.     const msg = this.create();
  2606.     const ms = Date.now();
  2607.     msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
  2608.     msg.nanos = ms % 1000 * 1e6;
  2609.     return msg;
  2610.   }
  2611.   toDate(message) {
  2612.     return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1e6));
  2613.   }
  2614.   fromDate(date) {
  2615.     const msg = this.create();
  2616.     const ms = date.getTime();
  2617.     msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
  2618.     msg.nanos = (ms % 1000 + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1e6;
  2619.     return msg;
  2620.   }
  2621.   internalJsonWrite(message, options) {
  2622.     let ms = PbLong.from(message.seconds).toNumber() * 1000;
  2623.     if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
  2624.       throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
  2625.     if (message.nanos < 0)
  2626.       throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
  2627.     let z = "Z";
  2628.     if (message.nanos > 0) {
  2629.       let nanosStr = (message.nanos + 1e9).toString().substring(1);
  2630.       if (nanosStr.substring(3) === "000000")
  2631.         z = "." + nanosStr.substring(0, 3) + "Z";
  2632.       else if (nanosStr.substring(6) === "000")
  2633.         z = "." + nanosStr.substring(0, 6) + "Z";
  2634.       else
  2635.         z = "." + nanosStr + "Z";
  2636.     }
  2637.     return new Date(ms).toISOString().replace(".000Z", z);
  2638.   }
  2639.   internalJsonRead(json, options, target) {
  2640.     if (typeof json !== "string")
  2641.       throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
  2642.     let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
  2643.     if (!matches)
  2644.       throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
  2645.     let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
  2646.     if (Number.isNaN(ms))
  2647.       throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
  2648.     if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
  2649.       throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
  2650.     if (!target)
  2651.       target = this.create();
  2652.     target.seconds = PbLong.from(ms / 1000).toBigInt();
  2653.     target.nanos = 0;
  2654.     if (matches[7])
  2655.       target.nanos = parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1e9;
  2656.     return target;
  2657.   }
  2658.   create(value) {
  2659.     const message = globalThis.Object.create(this.messagePrototype);
  2660.     message.seconds = 0n;
  2661.     message.nanos = 0;
  2662.     if (value !== undefined)
  2663.       reflectionMergePartial(this, message, value);
  2664.     return message;
  2665.   }
  2666.   internalBinaryRead(reader, length, options, target) {
  2667.     let message = target ?? this.create(), end = reader.pos + length;
  2668.     while (reader.pos < end) {
  2669.       let [fieldNo, wireType] = reader.tag();
  2670.       switch (fieldNo) {
  2671.         case 1:
  2672.           message.seconds = reader.int64().toBigInt();
  2673.           break;
  2674.         case 2:
  2675.           message.nanos = reader.int32();
  2676.           break;
  2677.         default:
  2678.           let u = options.readUnknownField;
  2679.           if (u === "throw")
  2680.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2681.           let d = reader.skip(wireType);
  2682.           if (u !== false)
  2683.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2684.       }
  2685.     }
  2686.     return message;
  2687.   }
  2688.   internalBinaryWrite(message, writer, options) {
  2689.     if (message.seconds !== 0n)
  2690.       writer.tag(1, WireType.Varint).int64(message.seconds);
  2691.     if (message.nanos !== 0)
  2692.       writer.tag(2, WireType.Varint).int32(message.nanos);
  2693.     let u = options.writeUnknownFields;
  2694.     if (u !== false)
  2695.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2696.     return writer;
  2697.   }
  2698. }
  2699. var Timestamp = new Timestamp$Type;
  2700.  
  2701. // node_modules/discord-protos/src/discord_protos/discord_users/v1/PreloadedUserSettings.ts
  2702. var PreloadedUserSettings_InboxTab;
  2703. ((PreloadedUserSettings_InboxTab2) => {
  2704.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
  2705.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["MENTIONS"] = 1] = "MENTIONS";
  2706.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["UNREADS"] = 2] = "UNREADS";
  2707.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["TODOS"] = 3] = "TODOS";
  2708.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["FOR_YOU"] = 4] = "FOR_YOU";
  2709.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["GAME_INVITES"] = 5] = "GAME_INVITES";
  2710.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["BOOKMARKS"] = 6] = "BOOKMARKS";
  2711.   PreloadedUserSettings_InboxTab2[PreloadedUserSettings_InboxTab2["SCHEDULED"] = 7] = "SCHEDULED";
  2712. })(PreloadedUserSettings_InboxTab ||= {});
  2713. var PreloadedUserSettings_DmSpamFilterV2;
  2714. ((PreloadedUserSettings_DmSpamFilterV22) => {
  2715.   PreloadedUserSettings_DmSpamFilterV22[PreloadedUserSettings_DmSpamFilterV22["DEFAULT_UNSET"] = 0] = "DEFAULT_UNSET";
  2716.   PreloadedUserSettings_DmSpamFilterV22[PreloadedUserSettings_DmSpamFilterV22["DISABLED"] = 1] = "DISABLED";
  2717.   PreloadedUserSettings_DmSpamFilterV22[PreloadedUserSettings_DmSpamFilterV22["NON_FRIENDS"] = 2] = "NON_FRIENDS";
  2718.   PreloadedUserSettings_DmSpamFilterV22[PreloadedUserSettings_DmSpamFilterV22["FRIENDS_AND_NON_FRIENDS"] = 3] = "FRIENDS_AND_NON_FRIENDS";
  2719. })(PreloadedUserSettings_DmSpamFilterV2 ||= {});
  2720. var PreloadedUserSettings_ExplicitContentRedaction;
  2721. ((PreloadedUserSettings_ExplicitContentRedaction2) => {
  2722.   PreloadedUserSettings_ExplicitContentRedaction2[PreloadedUserSettings_ExplicitContentRedaction2["UNSET_EXPLICIT_CONTENT_REDACTION"] = 0] = "UNSET_EXPLICIT_CONTENT_REDACTION";
  2723.   PreloadedUserSettings_ExplicitContentRedaction2[PreloadedUserSettings_ExplicitContentRedaction2["SHOW"] = 1] = "SHOW";
  2724.   PreloadedUserSettings_ExplicitContentRedaction2[PreloadedUserSettings_ExplicitContentRedaction2["BLUR"] = 2] = "BLUR";
  2725.   PreloadedUserSettings_ExplicitContentRedaction2[PreloadedUserSettings_ExplicitContentRedaction2["BLOCK"] = 3] = "BLOCK";
  2726. })(PreloadedUserSettings_ExplicitContentRedaction ||= {});
  2727. var PreloadedUserSettings_ReactionNotificationType;
  2728. ((PreloadedUserSettings_ReactionNotificationType2) => {
  2729.   PreloadedUserSettings_ReactionNotificationType2[PreloadedUserSettings_ReactionNotificationType2["NOTIFICATIONS_ENABLED"] = 0] = "NOTIFICATIONS_ENABLED";
  2730.   PreloadedUserSettings_ReactionNotificationType2[PreloadedUserSettings_ReactionNotificationType2["ONLY_DMS"] = 1] = "ONLY_DMS";
  2731.   PreloadedUserSettings_ReactionNotificationType2[PreloadedUserSettings_ReactionNotificationType2["NOTIFICATIONS_DISABLED"] = 2] = "NOTIFICATIONS_DISABLED";
  2732. })(PreloadedUserSettings_ReactionNotificationType ||= {});
  2733. var PreloadedUserSettings_GuildActivityStatusRestrictionDefault;
  2734. ((PreloadedUserSettings_GuildActivityStatusRestrictionDefault2) => {
  2735.   PreloadedUserSettings_GuildActivityStatusRestrictionDefault2[PreloadedUserSettings_GuildActivityStatusRestrictionDefault2["OFF"] = 0] = "OFF";
  2736.   PreloadedUserSettings_GuildActivityStatusRestrictionDefault2[PreloadedUserSettings_GuildActivityStatusRestrictionDefault2["ON_FOR_LARGE_GUILDS"] = 1] = "ON_FOR_LARGE_GUILDS";
  2737.   PreloadedUserSettings_GuildActivityStatusRestrictionDefault2[PreloadedUserSettings_GuildActivityStatusRestrictionDefault2["ON"] = 2] = "ON";
  2738. })(PreloadedUserSettings_GuildActivityStatusRestrictionDefault ||= {});
  2739. var PreloadedUserSettings_GuildsLeaderboardOptOutDefault;
  2740. ((PreloadedUserSettings_GuildsLeaderboardOptOutDefault2) => {
  2741.   PreloadedUserSettings_GuildsLeaderboardOptOutDefault2[PreloadedUserSettings_GuildsLeaderboardOptOutDefault2["OFF_FOR_NEW_GUILDS"] = 0] = "OFF_FOR_NEW_GUILDS";
  2742.   PreloadedUserSettings_GuildsLeaderboardOptOutDefault2[PreloadedUserSettings_GuildsLeaderboardOptOutDefault2["ON_FOR_NEW_GUILDS"] = 1] = "ON_FOR_NEW_GUILDS";
  2743. })(PreloadedUserSettings_GuildsLeaderboardOptOutDefault ||= {});
  2744. var PreloadedUserSettings_SlayerSDKReceiveInGameDMs;
  2745. ((PreloadedUserSettings_SlayerSDKReceiveInGameDMs2) => {
  2746.   PreloadedUserSettings_SlayerSDKReceiveInGameDMs2[PreloadedUserSettings_SlayerSDKReceiveInGameDMs2["SLAYER_SDK_RECEIVE_IN_GAME_DMS_UNSET"] = 0] = "SLAYER_SDK_RECEIVE_IN_GAME_DMS_UNSET";
  2747.   PreloadedUserSettings_SlayerSDKReceiveInGameDMs2[PreloadedUserSettings_SlayerSDKReceiveInGameDMs2["SLAYER_SDK_RECEIVE_IN_GAME_DMS_ALL"] = 1] = "SLAYER_SDK_RECEIVE_IN_GAME_DMS_ALL";
  2748.   PreloadedUserSettings_SlayerSDKReceiveInGameDMs2[PreloadedUserSettings_SlayerSDKReceiveInGameDMs2["SLAYER_SDK_RECEIVE_IN_GAME_DMS_USERS_WITH_GAME"] = 2] = "SLAYER_SDK_RECEIVE_IN_GAME_DMS_USERS_WITH_GAME";
  2749.   PreloadedUserSettings_SlayerSDKReceiveInGameDMs2[PreloadedUserSettings_SlayerSDKReceiveInGameDMs2["SLAYER_SDK_RECEIVE_IN_GAME_DMS_NONE"] = 3] = "SLAYER_SDK_RECEIVE_IN_GAME_DMS_NONE";
  2750. })(PreloadedUserSettings_SlayerSDKReceiveInGameDMs ||= {});
  2751. var PreloadedUserSettings_Theme;
  2752. ((PreloadedUserSettings_Theme2) => {
  2753.   PreloadedUserSettings_Theme2[PreloadedUserSettings_Theme2["UNSET"] = 0] = "UNSET";
  2754.   PreloadedUserSettings_Theme2[PreloadedUserSettings_Theme2["DARK"] = 1] = "DARK";
  2755.   PreloadedUserSettings_Theme2[PreloadedUserSettings_Theme2["LIGHT"] = 2] = "LIGHT";
  2756.   PreloadedUserSettings_Theme2[PreloadedUserSettings_Theme2["DARKER"] = 3] = "DARKER";
  2757.   PreloadedUserSettings_Theme2[PreloadedUserSettings_Theme2["MIDNIGHT"] = 4] = "MIDNIGHT";
  2758. })(PreloadedUserSettings_Theme ||= {});
  2759. var PreloadedUserSettings_TimestampHourCycle;
  2760. ((PreloadedUserSettings_TimestampHourCycle2) => {
  2761.   PreloadedUserSettings_TimestampHourCycle2[PreloadedUserSettings_TimestampHourCycle2["AUTO"] = 0] = "AUTO";
  2762.   PreloadedUserSettings_TimestampHourCycle2[PreloadedUserSettings_TimestampHourCycle2["H12"] = 1] = "H12";
  2763.   PreloadedUserSettings_TimestampHourCycle2[PreloadedUserSettings_TimestampHourCycle2["H23"] = 2] = "H23";
  2764. })(PreloadedUserSettings_TimestampHourCycle ||= {});
  2765. var PreloadedUserSettings_LaunchPadMode;
  2766. ((PreloadedUserSettings_LaunchPadMode2) => {
  2767.   PreloadedUserSettings_LaunchPadMode2[PreloadedUserSettings_LaunchPadMode2["LAUNCH_PAD_DISABLED"] = 0] = "LAUNCH_PAD_DISABLED";
  2768.   PreloadedUserSettings_LaunchPadMode2[PreloadedUserSettings_LaunchPadMode2["LAUNCH_PAD_GESTURE_FULL_SCREEN"] = 1] = "LAUNCH_PAD_GESTURE_FULL_SCREEN";
  2769.   PreloadedUserSettings_LaunchPadMode2[PreloadedUserSettings_LaunchPadMode2["LAUNCH_PAD_GESTURE_RIGHT_EDGE"] = 2] = "LAUNCH_PAD_GESTURE_RIGHT_EDGE";
  2770.   PreloadedUserSettings_LaunchPadMode2[PreloadedUserSettings_LaunchPadMode2["LAUNCH_PAD_PULL_TAB"] = 3] = "LAUNCH_PAD_PULL_TAB";
  2771. })(PreloadedUserSettings_LaunchPadMode ||= {});
  2772. var PreloadedUserSettings_UIDensity;
  2773. ((PreloadedUserSettings_UIDensity2) => {
  2774.   PreloadedUserSettings_UIDensity2[PreloadedUserSettings_UIDensity2["UI_DENSITY_UNSET_UI_DENSITY"] = 0] = "UI_DENSITY_UNSET_UI_DENSITY";
  2775.   PreloadedUserSettings_UIDensity2[PreloadedUserSettings_UIDensity2["UI_DENSITY_COMPACT"] = 1] = "UI_DENSITY_COMPACT";
  2776.   PreloadedUserSettings_UIDensity2[PreloadedUserSettings_UIDensity2["UI_DENSITY_COZY"] = 2] = "UI_DENSITY_COZY";
  2777.   PreloadedUserSettings_UIDensity2[PreloadedUserSettings_UIDensity2["UI_DENSITY_RESPONSIVE"] = 3] = "UI_DENSITY_RESPONSIVE";
  2778.   PreloadedUserSettings_UIDensity2[PreloadedUserSettings_UIDensity2["UI_DENSITY_DEFAULT"] = 4] = "UI_DENSITY_DEFAULT";
  2779. })(PreloadedUserSettings_UIDensity ||= {});
  2780. var PreloadedUserSettings_SwipeRightToLeftMode;
  2781. ((PreloadedUserSettings_SwipeRightToLeftMode2) => {
  2782.   PreloadedUserSettings_SwipeRightToLeftMode2[PreloadedUserSettings_SwipeRightToLeftMode2["SWIPE_RIGHT_TO_LEFT_UNSET"] = 0] = "SWIPE_RIGHT_TO_LEFT_UNSET";
  2783.   PreloadedUserSettings_SwipeRightToLeftMode2[PreloadedUserSettings_SwipeRightToLeftMode2["SWIPE_RIGHT_TO_LEFT_CHANNEL_DETAILS"] = 1] = "SWIPE_RIGHT_TO_LEFT_CHANNEL_DETAILS";
  2784.   PreloadedUserSettings_SwipeRightToLeftMode2[PreloadedUserSettings_SwipeRightToLeftMode2["SWIPE_RIGHT_TO_LEFT_REPLY"] = 2] = "SWIPE_RIGHT_TO_LEFT_REPLY";
  2785. })(PreloadedUserSettings_SwipeRightToLeftMode ||= {});
  2786. var PreloadedUserSettings_FavoriteChannelType;
  2787. ((PreloadedUserSettings_FavoriteChannelType2) => {
  2788.   PreloadedUserSettings_FavoriteChannelType2[PreloadedUserSettings_FavoriteChannelType2["UNSET_FAVORITE_CHANNEL_TYPE"] = 0] = "UNSET_FAVORITE_CHANNEL_TYPE";
  2789.   PreloadedUserSettings_FavoriteChannelType2[PreloadedUserSettings_FavoriteChannelType2["REFERENCE_ORIGINAL"] = 1] = "REFERENCE_ORIGINAL";
  2790.   PreloadedUserSettings_FavoriteChannelType2[PreloadedUserSettings_FavoriteChannelType2["CATEGORY"] = 2] = "CATEGORY";
  2791. })(PreloadedUserSettings_FavoriteChannelType ||= {});
  2792. var PreloadedUserSettings_ForLaterTab;
  2793. ((PreloadedUserSettings_ForLaterTab2) => {
  2794.   PreloadedUserSettings_ForLaterTab2[PreloadedUserSettings_ForLaterTab2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
  2795.   PreloadedUserSettings_ForLaterTab2[PreloadedUserSettings_ForLaterTab2["ALL"] = 1] = "ALL";
  2796.   PreloadedUserSettings_ForLaterTab2[PreloadedUserSettings_ForLaterTab2["BOOKMARKS"] = 2] = "BOOKMARKS";
  2797.   PreloadedUserSettings_ForLaterTab2[PreloadedUserSettings_ForLaterTab2["REMINDERS"] = 3] = "REMINDERS";
  2798. })(PreloadedUserSettings_ForLaterTab ||= {});
  2799. var PreloadedUserSettings_SafetySettingsPresetType;
  2800. ((PreloadedUserSettings_SafetySettingsPresetType2) => {
  2801.   PreloadedUserSettings_SafetySettingsPresetType2[PreloadedUserSettings_SafetySettingsPresetType2["UNSET_SAFETY_SETTINGS_PRESET"] = 0] = "UNSET_SAFETY_SETTINGS_PRESET";
  2802.   PreloadedUserSettings_SafetySettingsPresetType2[PreloadedUserSettings_SafetySettingsPresetType2["BALANCED"] = 1] = "BALANCED";
  2803.   PreloadedUserSettings_SafetySettingsPresetType2[PreloadedUserSettings_SafetySettingsPresetType2["STRICT"] = 2] = "STRICT";
  2804.   PreloadedUserSettings_SafetySettingsPresetType2[PreloadedUserSettings_SafetySettingsPresetType2["RELAXED"] = 3] = "RELAXED";
  2805.   PreloadedUserSettings_SafetySettingsPresetType2[PreloadedUserSettings_SafetySettingsPresetType2["CUSTOM"] = 4] = "CUSTOM";
  2806. })(PreloadedUserSettings_SafetySettingsPresetType ||= {});
  2807.  
  2808. class PreloadedUserSettings$Type extends MessageType {
  2809.   constructor() {
  2810.     super("discord_protos.discord_users.v1.PreloadedUserSettings", [
  2811.       { no: 1, name: "versions", kind: "message", T: () => PreloadedUserSettings_Versions },
  2812.       { no: 2, name: "inbox", kind: "message", T: () => PreloadedUserSettings_InboxSettings },
  2813.       { no: 3, name: "guilds", kind: "message", T: () => PreloadedUserSettings_AllGuildSettings },
  2814.       { no: 4, name: "user_content", kind: "message", T: () => PreloadedUserSettings_UserContentSettings },
  2815.       { no: 5, name: "voice_and_video", kind: "message", T: () => PreloadedUserSettings_VoiceAndVideoSettings },
  2816.       { no: 6, name: "text_and_images", kind: "message", T: () => PreloadedUserSettings_TextAndImagesSettings },
  2817.       { no: 7, name: "notifications", kind: "message", T: () => PreloadedUserSettings_NotificationSettings },
  2818.       { no: 8, name: "privacy", kind: "message", T: () => PreloadedUserSettings_PrivacySettings },
  2819.       { no: 9, name: "debug", kind: "message", T: () => PreloadedUserSettings_DebugSettings },
  2820.       { no: 10, name: "game_library", kind: "message", T: () => PreloadedUserSettings_GameLibrarySettings },
  2821.       { no: 11, name: "status", kind: "message", T: () => PreloadedUserSettings_StatusSettings },
  2822.       { no: 12, name: "localization", kind: "message", T: () => PreloadedUserSettings_LocalizationSettings },
  2823.       { no: 13, name: "appearance", kind: "message", T: () => PreloadedUserSettings_AppearanceSettings },
  2824.       { no: 14, name: "guild_folders", kind: "message", T: () => PreloadedUserSettings_GuildFolders },
  2825.       { no: 15, name: "favorites", kind: "message", T: () => PreloadedUserSettings_Favorites },
  2826.       { no: 16, name: "audio_context_settings", kind: "message", T: () => PreloadedUserSettings_AudioSettings },
  2827.       { no: 17, name: "communities", kind: "message", T: () => PreloadedUserSettings_CommunitiesSettings },
  2828.       { no: 18, name: "broadcast", kind: "message", T: () => PreloadedUserSettings_BroadcastSettings },
  2829.       { no: 19, name: "clips", kind: "message", T: () => PreloadedUserSettings_ClipsSettings },
  2830.       { no: 20, name: "for_later", kind: "message", T: () => PreloadedUserSettings_ForLaterSettings },
  2831.       { no: 21, name: "safety_settings", kind: "message", T: () => PreloadedUserSettings_SafetySettings },
  2832.       { no: 22, name: "icymi_settings", kind: "message", T: () => PreloadedUserSettings_ICYMISettings },
  2833.       { no: 23, name: "applications", kind: "message", T: () => PreloadedUserSettings_AllApplicationSettings },
  2834.       { no: 24, name: "ads", kind: "message", T: () => PreloadedUserSettings_AdsSettings }
  2835.     ]);
  2836.   }
  2837.   create(value) {
  2838.     const message = globalThis.Object.create(this.messagePrototype);
  2839.     if (value !== undefined)
  2840.       reflectionMergePartial(this, message, value);
  2841.     return message;
  2842.   }
  2843.   internalBinaryRead(reader, length, options, target) {
  2844.     let message = target ?? this.create(), end = reader.pos + length;
  2845.     while (reader.pos < end) {
  2846.       let [fieldNo, wireType] = reader.tag();
  2847.       switch (fieldNo) {
  2848.         case 1:
  2849.           message.versions = PreloadedUserSettings_Versions.internalBinaryRead(reader, reader.uint32(), options, message.versions);
  2850.           break;
  2851.         case 2:
  2852.           message.inbox = PreloadedUserSettings_InboxSettings.internalBinaryRead(reader, reader.uint32(), options, message.inbox);
  2853.           break;
  2854.         case 3:
  2855.           message.guilds = PreloadedUserSettings_AllGuildSettings.internalBinaryRead(reader, reader.uint32(), options, message.guilds);
  2856.           break;
  2857.         case 4:
  2858.           message.userContent = PreloadedUserSettings_UserContentSettings.internalBinaryRead(reader, reader.uint32(), options, message.userContent);
  2859.           break;
  2860.         case 5:
  2861.           message.voiceAndVideo = PreloadedUserSettings_VoiceAndVideoSettings.internalBinaryRead(reader, reader.uint32(), options, message.voiceAndVideo);
  2862.           break;
  2863.         case 6:
  2864.           message.textAndImages = PreloadedUserSettings_TextAndImagesSettings.internalBinaryRead(reader, reader.uint32(), options, message.textAndImages);
  2865.           break;
  2866.         case 7:
  2867.           message.notifications = PreloadedUserSettings_NotificationSettings.internalBinaryRead(reader, reader.uint32(), options, message.notifications);
  2868.           break;
  2869.         case 8:
  2870.           message.privacy = PreloadedUserSettings_PrivacySettings.internalBinaryRead(reader, reader.uint32(), options, message.privacy);
  2871.           break;
  2872.         case 9:
  2873.           message.debug = PreloadedUserSettings_DebugSettings.internalBinaryRead(reader, reader.uint32(), options, message.debug);
  2874.           break;
  2875.         case 10:
  2876.           message.gameLibrary = PreloadedUserSettings_GameLibrarySettings.internalBinaryRead(reader, reader.uint32(), options, message.gameLibrary);
  2877.           break;
  2878.         case 11:
  2879.           message.status = PreloadedUserSettings_StatusSettings.internalBinaryRead(reader, reader.uint32(), options, message.status);
  2880.           break;
  2881.         case 12:
  2882.           message.localization = PreloadedUserSettings_LocalizationSettings.internalBinaryRead(reader, reader.uint32(), options, message.localization);
  2883.           break;
  2884.         case 13:
  2885.           message.appearance = PreloadedUserSettings_AppearanceSettings.internalBinaryRead(reader, reader.uint32(), options, message.appearance);
  2886.           break;
  2887.         case 14:
  2888.           message.guildFolders = PreloadedUserSettings_GuildFolders.internalBinaryRead(reader, reader.uint32(), options, message.guildFolders);
  2889.           break;
  2890.         case 15:
  2891.           message.favorites = PreloadedUserSettings_Favorites.internalBinaryRead(reader, reader.uint32(), options, message.favorites);
  2892.           break;
  2893.         case 16:
  2894.           message.audioContextSettings = PreloadedUserSettings_AudioSettings.internalBinaryRead(reader, reader.uint32(), options, message.audioContextSettings);
  2895.           break;
  2896.         case 17:
  2897.           message.communities = PreloadedUserSettings_CommunitiesSettings.internalBinaryRead(reader, reader.uint32(), options, message.communities);
  2898.           break;
  2899.         case 18:
  2900.           message.broadcast = PreloadedUserSettings_BroadcastSettings.internalBinaryRead(reader, reader.uint32(), options, message.broadcast);
  2901.           break;
  2902.         case 19:
  2903.           message.clips = PreloadedUserSettings_ClipsSettings.internalBinaryRead(reader, reader.uint32(), options, message.clips);
  2904.           break;
  2905.         case 20:
  2906.           message.forLater = PreloadedUserSettings_ForLaterSettings.internalBinaryRead(reader, reader.uint32(), options, message.forLater);
  2907.           break;
  2908.         case 21:
  2909.           message.safetySettings = PreloadedUserSettings_SafetySettings.internalBinaryRead(reader, reader.uint32(), options, message.safetySettings);
  2910.           break;
  2911.         case 22:
  2912.           message.icymiSettings = PreloadedUserSettings_ICYMISettings.internalBinaryRead(reader, reader.uint32(), options, message.icymiSettings);
  2913.           break;
  2914.         case 23:
  2915.           message.applications = PreloadedUserSettings_AllApplicationSettings.internalBinaryRead(reader, reader.uint32(), options, message.applications);
  2916.           break;
  2917.         case 24:
  2918.           message.ads = PreloadedUserSettings_AdsSettings.internalBinaryRead(reader, reader.uint32(), options, message.ads);
  2919.           break;
  2920.         default:
  2921.           let u = options.readUnknownField;
  2922.           if (u === "throw")
  2923.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  2924.           let d = reader.skip(wireType);
  2925.           if (u !== false)
  2926.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  2927.       }
  2928.     }
  2929.     return message;
  2930.   }
  2931.   internalBinaryWrite(message, writer, options) {
  2932.     if (message.versions)
  2933.       PreloadedUserSettings_Versions.internalBinaryWrite(message.versions, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  2934.     if (message.inbox)
  2935.       PreloadedUserSettings_InboxSettings.internalBinaryWrite(message.inbox, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  2936.     if (message.guilds)
  2937.       PreloadedUserSettings_AllGuildSettings.internalBinaryWrite(message.guilds, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  2938.     if (message.userContent)
  2939.       PreloadedUserSettings_UserContentSettings.internalBinaryWrite(message.userContent, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  2940.     if (message.voiceAndVideo)
  2941.       PreloadedUserSettings_VoiceAndVideoSettings.internalBinaryWrite(message.voiceAndVideo, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  2942.     if (message.textAndImages)
  2943.       PreloadedUserSettings_TextAndImagesSettings.internalBinaryWrite(message.textAndImages, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  2944.     if (message.notifications)
  2945.       PreloadedUserSettings_NotificationSettings.internalBinaryWrite(message.notifications, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  2946.     if (message.privacy)
  2947.       PreloadedUserSettings_PrivacySettings.internalBinaryWrite(message.privacy, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  2948.     if (message.debug)
  2949.       PreloadedUserSettings_DebugSettings.internalBinaryWrite(message.debug, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  2950.     if (message.gameLibrary)
  2951.       PreloadedUserSettings_GameLibrarySettings.internalBinaryWrite(message.gameLibrary, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  2952.     if (message.status)
  2953.       PreloadedUserSettings_StatusSettings.internalBinaryWrite(message.status, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  2954.     if (message.localization)
  2955.       PreloadedUserSettings_LocalizationSettings.internalBinaryWrite(message.localization, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
  2956.     if (message.appearance)
  2957.       PreloadedUserSettings_AppearanceSettings.internalBinaryWrite(message.appearance, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
  2958.     if (message.guildFolders)
  2959.       PreloadedUserSettings_GuildFolders.internalBinaryWrite(message.guildFolders, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
  2960.     if (message.favorites)
  2961.       PreloadedUserSettings_Favorites.internalBinaryWrite(message.favorites, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
  2962.     if (message.audioContextSettings)
  2963.       PreloadedUserSettings_AudioSettings.internalBinaryWrite(message.audioContextSettings, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
  2964.     if (message.communities)
  2965.       PreloadedUserSettings_CommunitiesSettings.internalBinaryWrite(message.communities, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
  2966.     if (message.broadcast)
  2967.       PreloadedUserSettings_BroadcastSettings.internalBinaryWrite(message.broadcast, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
  2968.     if (message.clips)
  2969.       PreloadedUserSettings_ClipsSettings.internalBinaryWrite(message.clips, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
  2970.     if (message.forLater)
  2971.       PreloadedUserSettings_ForLaterSettings.internalBinaryWrite(message.forLater, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
  2972.     if (message.safetySettings)
  2973.       PreloadedUserSettings_SafetySettings.internalBinaryWrite(message.safetySettings, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
  2974.     if (message.icymiSettings)
  2975.       PreloadedUserSettings_ICYMISettings.internalBinaryWrite(message.icymiSettings, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
  2976.     if (message.applications)
  2977.       PreloadedUserSettings_AllApplicationSettings.internalBinaryWrite(message.applications, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
  2978.     if (message.ads)
  2979.       PreloadedUserSettings_AdsSettings.internalBinaryWrite(message.ads, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
  2980.     let u = options.writeUnknownFields;
  2981.     if (u !== false)
  2982.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  2983.     return writer;
  2984.   }
  2985. }
  2986. var PreloadedUserSettings = new PreloadedUserSettings$Type;
  2987.  
  2988. class PreloadedUserSettings_Versions$Type extends MessageType {
  2989.   constructor() {
  2990.     super("discord_protos.discord_users.v1.PreloadedUserSettings.Versions", [
  2991.       { no: 1, name: "client_version", kind: "scalar", T: 13 },
  2992.       { no: 2, name: "server_version", kind: "scalar", T: 13 },
  2993.       { no: 3, name: "data_version", kind: "scalar", T: 13 }
  2994.     ]);
  2995.   }
  2996.   create(value) {
  2997.     const message = globalThis.Object.create(this.messagePrototype);
  2998.     message.clientVersion = 0;
  2999.     message.serverVersion = 0;
  3000.     message.dataVersion = 0;
  3001.     if (value !== undefined)
  3002.       reflectionMergePartial(this, message, value);
  3003.     return message;
  3004.   }
  3005.   internalBinaryRead(reader, length, options, target) {
  3006.     let message = target ?? this.create(), end = reader.pos + length;
  3007.     while (reader.pos < end) {
  3008.       let [fieldNo, wireType] = reader.tag();
  3009.       switch (fieldNo) {
  3010.         case 1:
  3011.           message.clientVersion = reader.uint32();
  3012.           break;
  3013.         case 2:
  3014.           message.serverVersion = reader.uint32();
  3015.           break;
  3016.         case 3:
  3017.           message.dataVersion = reader.uint32();
  3018.           break;
  3019.         default:
  3020.           let u = options.readUnknownField;
  3021.           if (u === "throw")
  3022.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3023.           let d = reader.skip(wireType);
  3024.           if (u !== false)
  3025.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3026.       }
  3027.     }
  3028.     return message;
  3029.   }
  3030.   internalBinaryWrite(message, writer, options) {
  3031.     if (message.clientVersion !== 0)
  3032.       writer.tag(1, WireType.Varint).uint32(message.clientVersion);
  3033.     if (message.serverVersion !== 0)
  3034.       writer.tag(2, WireType.Varint).uint32(message.serverVersion);
  3035.     if (message.dataVersion !== 0)
  3036.       writer.tag(3, WireType.Varint).uint32(message.dataVersion);
  3037.     let u = options.writeUnknownFields;
  3038.     if (u !== false)
  3039.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3040.     return writer;
  3041.   }
  3042. }
  3043. var PreloadedUserSettings_Versions = new PreloadedUserSettings_Versions$Type;
  3044.  
  3045. class PreloadedUserSettings_InboxSettings$Type extends MessageType {
  3046.   constructor() {
  3047.     super("discord_protos.discord_users.v1.PreloadedUserSettings.InboxSettings", [
  3048.       { no: 1, name: "current_tab", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.InboxTab", PreloadedUserSettings_InboxTab, "INBOX_TAB_"] },
  3049.       { no: 2, name: "viewed_tutorial", kind: "scalar", T: 8 }
  3050.     ]);
  3051.   }
  3052.   create(value) {
  3053.     const message = globalThis.Object.create(this.messagePrototype);
  3054.     message.currentTab = 0;
  3055.     message.viewedTutorial = false;
  3056.     if (value !== undefined)
  3057.       reflectionMergePartial(this, message, value);
  3058.     return message;
  3059.   }
  3060.   internalBinaryRead(reader, length, options, target) {
  3061.     let message = target ?? this.create(), end = reader.pos + length;
  3062.     while (reader.pos < end) {
  3063.       let [fieldNo, wireType] = reader.tag();
  3064.       switch (fieldNo) {
  3065.         case 1:
  3066.           message.currentTab = reader.int32();
  3067.           break;
  3068.         case 2:
  3069.           message.viewedTutorial = reader.bool();
  3070.           break;
  3071.         default:
  3072.           let u = options.readUnknownField;
  3073.           if (u === "throw")
  3074.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3075.           let d = reader.skip(wireType);
  3076.           if (u !== false)
  3077.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3078.       }
  3079.     }
  3080.     return message;
  3081.   }
  3082.   internalBinaryWrite(message, writer, options) {
  3083.     if (message.currentTab !== 0)
  3084.       writer.tag(1, WireType.Varint).int32(message.currentTab);
  3085.     if (message.viewedTutorial !== false)
  3086.       writer.tag(2, WireType.Varint).bool(message.viewedTutorial);
  3087.     let u = options.writeUnknownFields;
  3088.     if (u !== false)
  3089.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3090.     return writer;
  3091.   }
  3092. }
  3093. var PreloadedUserSettings_InboxSettings = new PreloadedUserSettings_InboxSettings$Type;
  3094.  
  3095. class PreloadedUserSettings_ChannelIconEmoji$Type extends MessageType {
  3096.   constructor() {
  3097.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ChannelIconEmoji", [
  3098.       { no: 1, name: "id", kind: "message", T: () => UInt64Value },
  3099.       { no: 2, name: "name", kind: "message", T: () => StringValue },
  3100.       { no: 3, name: "color", kind: "message", T: () => UInt64Value }
  3101.     ]);
  3102.   }
  3103.   create(value) {
  3104.     const message = globalThis.Object.create(this.messagePrototype);
  3105.     if (value !== undefined)
  3106.       reflectionMergePartial(this, message, value);
  3107.     return message;
  3108.   }
  3109.   internalBinaryRead(reader, length, options, target) {
  3110.     let message = target ?? this.create(), end = reader.pos + length;
  3111.     while (reader.pos < end) {
  3112.       let [fieldNo, wireType] = reader.tag();
  3113.       switch (fieldNo) {
  3114.         case 1:
  3115.           message.id = UInt64Value.internalBinaryRead(reader, reader.uint32(), options, message.id);
  3116.           break;
  3117.         case 2:
  3118.           message.name = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.name);
  3119.           break;
  3120.         case 3:
  3121.           message.color = UInt64Value.internalBinaryRead(reader, reader.uint32(), options, message.color);
  3122.           break;
  3123.         default:
  3124.           let u = options.readUnknownField;
  3125.           if (u === "throw")
  3126.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3127.           let d = reader.skip(wireType);
  3128.           if (u !== false)
  3129.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3130.       }
  3131.     }
  3132.     return message;
  3133.   }
  3134.   internalBinaryWrite(message, writer, options) {
  3135.     if (message.id)
  3136.       UInt64Value.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  3137.     if (message.name)
  3138.       StringValue.internalBinaryWrite(message.name, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  3139.     if (message.color)
  3140.       UInt64Value.internalBinaryWrite(message.color, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  3141.     let u = options.writeUnknownFields;
  3142.     if (u !== false)
  3143.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3144.     return writer;
  3145.   }
  3146. }
  3147. var PreloadedUserSettings_ChannelIconEmoji = new PreloadedUserSettings_ChannelIconEmoji$Type;
  3148.  
  3149. class PreloadedUserSettings_CustomNotificationSoundConfig$Type extends MessageType {
  3150.   constructor() {
  3151.     super("discord_protos.discord_users.v1.PreloadedUserSettings.CustomNotificationSoundConfig", [
  3152.       { no: 1, name: "notification_sound_pack_id", kind: "message", T: () => StringValue }
  3153.     ]);
  3154.   }
  3155.   create(value) {
  3156.     const message = globalThis.Object.create(this.messagePrototype);
  3157.     if (value !== undefined)
  3158.       reflectionMergePartial(this, message, value);
  3159.     return message;
  3160.   }
  3161.   internalBinaryRead(reader, length, options, target) {
  3162.     let message = target ?? this.create(), end = reader.pos + length;
  3163.     while (reader.pos < end) {
  3164.       let [fieldNo, wireType] = reader.tag();
  3165.       switch (fieldNo) {
  3166.         case 1:
  3167.           message.notificationSoundPackId = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.notificationSoundPackId);
  3168.           break;
  3169.         default:
  3170.           let u = options.readUnknownField;
  3171.           if (u === "throw")
  3172.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3173.           let d = reader.skip(wireType);
  3174.           if (u !== false)
  3175.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3176.       }
  3177.     }
  3178.     return message;
  3179.   }
  3180.   internalBinaryWrite(message, writer, options) {
  3181.     if (message.notificationSoundPackId)
  3182.       StringValue.internalBinaryWrite(message.notificationSoundPackId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  3183.     let u = options.writeUnknownFields;
  3184.     if (u !== false)
  3185.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3186.     return writer;
  3187.   }
  3188. }
  3189. var PreloadedUserSettings_CustomNotificationSoundConfig = new PreloadedUserSettings_CustomNotificationSoundConfig$Type;
  3190.  
  3191. class PreloadedUserSettings_ChannelSettings$Type extends MessageType {
  3192.   constructor() {
  3193.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ChannelSettings", [
  3194.       { no: 1, name: "collapsed_in_inbox", kind: "scalar", T: 8 },
  3195.       { no: 2, name: "icon_emoji", kind: "message", T: () => PreloadedUserSettings_ChannelIconEmoji },
  3196.       { no: 3, name: "custom_notification_sound_config", kind: "message", T: () => PreloadedUserSettings_CustomNotificationSoundConfig }
  3197.     ]);
  3198.   }
  3199.   create(value) {
  3200.     const message = globalThis.Object.create(this.messagePrototype);
  3201.     message.collapsedInInbox = false;
  3202.     if (value !== undefined)
  3203.       reflectionMergePartial(this, message, value);
  3204.     return message;
  3205.   }
  3206.   internalBinaryRead(reader, length, options, target) {
  3207.     let message = target ?? this.create(), end = reader.pos + length;
  3208.     while (reader.pos < end) {
  3209.       let [fieldNo, wireType] = reader.tag();
  3210.       switch (fieldNo) {
  3211.         case 1:
  3212.           message.collapsedInInbox = reader.bool();
  3213.           break;
  3214.         case 2:
  3215.           message.iconEmoji = PreloadedUserSettings_ChannelIconEmoji.internalBinaryRead(reader, reader.uint32(), options, message.iconEmoji);
  3216.           break;
  3217.         case 3:
  3218.           message.customNotificationSoundConfig = PreloadedUserSettings_CustomNotificationSoundConfig.internalBinaryRead(reader, reader.uint32(), options, message.customNotificationSoundConfig);
  3219.           break;
  3220.         default:
  3221.           let u = options.readUnknownField;
  3222.           if (u === "throw")
  3223.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3224.           let d = reader.skip(wireType);
  3225.           if (u !== false)
  3226.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3227.       }
  3228.     }
  3229.     return message;
  3230.   }
  3231.   internalBinaryWrite(message, writer, options) {
  3232.     if (message.collapsedInInbox !== false)
  3233.       writer.tag(1, WireType.Varint).bool(message.collapsedInInbox);
  3234.     if (message.iconEmoji)
  3235.       PreloadedUserSettings_ChannelIconEmoji.internalBinaryWrite(message.iconEmoji, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  3236.     if (message.customNotificationSoundConfig)
  3237.       PreloadedUserSettings_CustomNotificationSoundConfig.internalBinaryWrite(message.customNotificationSoundConfig, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  3238.     let u = options.writeUnknownFields;
  3239.     if (u !== false)
  3240.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3241.     return writer;
  3242.   }
  3243. }
  3244. var PreloadedUserSettings_ChannelSettings = new PreloadedUserSettings_ChannelSettings$Type;
  3245.  
  3246. class PreloadedUserSettings_CustomCallSound$Type extends MessageType {
  3247.   constructor() {
  3248.     super("discord_protos.discord_users.v1.PreloadedUserSettings.CustomCallSound", [
  3249.       { no: 1, name: "sound_id", kind: "scalar", T: 6, L: 0 },
  3250.       { no: 2, name: "guild_id", kind: "scalar", T: 6, L: 0 }
  3251.     ]);
  3252.   }
  3253.   create(value) {
  3254.     const message = globalThis.Object.create(this.messagePrototype);
  3255.     message.soundId = 0n;
  3256.     message.guildId = 0n;
  3257.     if (value !== undefined)
  3258.       reflectionMergePartial(this, message, value);
  3259.     return message;
  3260.   }
  3261.   internalBinaryRead(reader, length, options, target) {
  3262.     let message = target ?? this.create(), end = reader.pos + length;
  3263.     while (reader.pos < end) {
  3264.       let [fieldNo, wireType] = reader.tag();
  3265.       switch (fieldNo) {
  3266.         case 1:
  3267.           message.soundId = reader.fixed64().toBigInt();
  3268.           break;
  3269.         case 2:
  3270.           message.guildId = reader.fixed64().toBigInt();
  3271.           break;
  3272.         default:
  3273.           let u = options.readUnknownField;
  3274.           if (u === "throw")
  3275.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3276.           let d = reader.skip(wireType);
  3277.           if (u !== false)
  3278.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3279.       }
  3280.     }
  3281.     return message;
  3282.   }
  3283.   internalBinaryWrite(message, writer, options) {
  3284.     if (message.soundId !== 0n)
  3285.       writer.tag(1, WireType.Bit64).fixed64(message.soundId);
  3286.     if (message.guildId !== 0n)
  3287.       writer.tag(2, WireType.Bit64).fixed64(message.guildId);
  3288.     let u = options.writeUnknownFields;
  3289.     if (u !== false)
  3290.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3291.     return writer;
  3292.   }
  3293. }
  3294. var PreloadedUserSettings_CustomCallSound = new PreloadedUserSettings_CustomCallSound$Type;
  3295.  
  3296. class PreloadedUserSettings_ChannelListSettings$Type extends MessageType {
  3297.   constructor() {
  3298.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ChannelListSettings", [
  3299.       { no: 1, name: "layout", kind: "message", T: () => StringValue },
  3300.       { no: 2, name: "message_previews", kind: "message", T: () => StringValue }
  3301.     ]);
  3302.   }
  3303.   create(value) {
  3304.     const message = globalThis.Object.create(this.messagePrototype);
  3305.     if (value !== undefined)
  3306.       reflectionMergePartial(this, message, value);
  3307.     return message;
  3308.   }
  3309.   internalBinaryRead(reader, length, options, target) {
  3310.     let message = target ?? this.create(), end = reader.pos + length;
  3311.     while (reader.pos < end) {
  3312.       let [fieldNo, wireType] = reader.tag();
  3313.       switch (fieldNo) {
  3314.         case 1:
  3315.           message.layout = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.layout);
  3316.           break;
  3317.         case 2:
  3318.           message.messagePreviews = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.messagePreviews);
  3319.           break;
  3320.         default:
  3321.           let u = options.readUnknownField;
  3322.           if (u === "throw")
  3323.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3324.           let d = reader.skip(wireType);
  3325.           if (u !== false)
  3326.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3327.       }
  3328.     }
  3329.     return message;
  3330.   }
  3331.   internalBinaryWrite(message, writer, options) {
  3332.     if (message.layout)
  3333.       StringValue.internalBinaryWrite(message.layout, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  3334.     if (message.messagePreviews)
  3335.       StringValue.internalBinaryWrite(message.messagePreviews, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  3336.     let u = options.writeUnknownFields;
  3337.     if (u !== false)
  3338.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3339.     return writer;
  3340.   }
  3341. }
  3342. var PreloadedUserSettings_ChannelListSettings = new PreloadedUserSettings_ChannelListSettings$Type;
  3343.  
  3344. class PreloadedUserSettings_GuildSettings$Type extends MessageType {
  3345.   constructor() {
  3346.     super("discord_protos.discord_users.v1.PreloadedUserSettings.GuildSettings", [
  3347.       { no: 1, name: "channels", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_ChannelSettings } },
  3348.       { no: 2, name: "hub_progress", kind: "scalar", T: 13 },
  3349.       { no: 3, name: "guild_onboarding_progress", kind: "scalar", T: 13 },
  3350.       { no: 4, name: "guild_recents_dismissed_at", kind: "message", T: () => Timestamp },
  3351.       { no: 5, name: "dismissed_guild_content", kind: "scalar", T: 12 },
  3352.       { no: 6, name: "join_sound", kind: "message", T: () => PreloadedUserSettings_CustomCallSound },
  3353.       { no: 7, name: "mobile_redesign_channel_list_settings", kind: "message", T: () => PreloadedUserSettings_ChannelListSettings },
  3354.       { no: 8, name: "disable_raid_alert_push", kind: "scalar", T: 8 },
  3355.       { no: 9, name: "disable_raid_alert_nag", kind: "scalar", T: 8 },
  3356.       { no: 10, name: "custom_notification_sound_config", kind: "message", T: () => PreloadedUserSettings_CustomNotificationSoundConfig },
  3357.       { no: 11, name: "leaderboards_disabled", kind: "scalar", T: 8 }
  3358.     ]);
  3359.   }
  3360.   create(value) {
  3361.     const message = globalThis.Object.create(this.messagePrototype);
  3362.     message.channels = {};
  3363.     message.hubProgress = 0;
  3364.     message.guildOnboardingProgress = 0;
  3365.     message.dismissedGuildContent = new Uint8Array(0);
  3366.     message.disableRaidAlertPush = false;
  3367.     message.disableRaidAlertNag = false;
  3368.     message.leaderboardsDisabled = false;
  3369.     if (value !== undefined)
  3370.       reflectionMergePartial(this, message, value);
  3371.     return message;
  3372.   }
  3373.   internalBinaryRead(reader, length, options, target) {
  3374.     let message = target ?? this.create(), end = reader.pos + length;
  3375.     while (reader.pos < end) {
  3376.       let [fieldNo, wireType] = reader.tag();
  3377.       switch (fieldNo) {
  3378.         case 1:
  3379.           this.binaryReadMap1(message.channels, reader, options);
  3380.           break;
  3381.         case 2:
  3382.           message.hubProgress = reader.uint32();
  3383.           break;
  3384.         case 3:
  3385.           message.guildOnboardingProgress = reader.uint32();
  3386.           break;
  3387.         case 4:
  3388.           message.guildRecentsDismissedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.guildRecentsDismissedAt);
  3389.           break;
  3390.         case 5:
  3391.           message.dismissedGuildContent = reader.bytes();
  3392.           break;
  3393.         case 6:
  3394.           message.joinSound = PreloadedUserSettings_CustomCallSound.internalBinaryRead(reader, reader.uint32(), options, message.joinSound);
  3395.           break;
  3396.         case 7:
  3397.           message.mobileRedesignChannelListSettings = PreloadedUserSettings_ChannelListSettings.internalBinaryRead(reader, reader.uint32(), options, message.mobileRedesignChannelListSettings);
  3398.           break;
  3399.         case 8:
  3400.           message.disableRaidAlertPush = reader.bool();
  3401.           break;
  3402.         case 9:
  3403.           message.disableRaidAlertNag = reader.bool();
  3404.           break;
  3405.         case 10:
  3406.           message.customNotificationSoundConfig = PreloadedUserSettings_CustomNotificationSoundConfig.internalBinaryRead(reader, reader.uint32(), options, message.customNotificationSoundConfig);
  3407.           break;
  3408.         case 11:
  3409.           message.leaderboardsDisabled = reader.bool();
  3410.           break;
  3411.         default:
  3412.           let u = options.readUnknownField;
  3413.           if (u === "throw")
  3414.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3415.           let d = reader.skip(wireType);
  3416.           if (u !== false)
  3417.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3418.       }
  3419.     }
  3420.     return message;
  3421.   }
  3422.   binaryReadMap1(map, reader, options) {
  3423.     let len = reader.uint32(), end = reader.pos + len, key, val;
  3424.     while (reader.pos < end) {
  3425.       let [fieldNo, wireType] = reader.tag();
  3426.       switch (fieldNo) {
  3427.         case 1:
  3428.           key = reader.fixed64().toString();
  3429.           break;
  3430.         case 2:
  3431.           val = PreloadedUserSettings_ChannelSettings.internalBinaryRead(reader, reader.uint32(), options);
  3432.           break;
  3433.         default:
  3434.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.GuildSettings.channels");
  3435.       }
  3436.     }
  3437.     map[key ?? "0"] = val ?? PreloadedUserSettings_ChannelSettings.create();
  3438.   }
  3439.   internalBinaryWrite(message, writer, options) {
  3440.     for (let k of globalThis.Object.keys(message.channels)) {
  3441.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  3442.       writer.tag(2, WireType.LengthDelimited).fork();
  3443.       PreloadedUserSettings_ChannelSettings.internalBinaryWrite(message.channels[k], writer, options);
  3444.       writer.join().join();
  3445.     }
  3446.     if (message.hubProgress !== 0)
  3447.       writer.tag(2, WireType.Varint).uint32(message.hubProgress);
  3448.     if (message.guildOnboardingProgress !== 0)
  3449.       writer.tag(3, WireType.Varint).uint32(message.guildOnboardingProgress);
  3450.     if (message.guildRecentsDismissedAt)
  3451.       Timestamp.internalBinaryWrite(message.guildRecentsDismissedAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  3452.     if (message.dismissedGuildContent.length)
  3453.       writer.tag(5, WireType.LengthDelimited).bytes(message.dismissedGuildContent);
  3454.     if (message.joinSound)
  3455.       PreloadedUserSettings_CustomCallSound.internalBinaryWrite(message.joinSound, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  3456.     if (message.mobileRedesignChannelListSettings)
  3457.       PreloadedUserSettings_ChannelListSettings.internalBinaryWrite(message.mobileRedesignChannelListSettings, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  3458.     if (message.disableRaidAlertPush !== false)
  3459.       writer.tag(8, WireType.Varint).bool(message.disableRaidAlertPush);
  3460.     if (message.disableRaidAlertNag !== false)
  3461.       writer.tag(9, WireType.Varint).bool(message.disableRaidAlertNag);
  3462.     if (message.customNotificationSoundConfig)
  3463.       PreloadedUserSettings_CustomNotificationSoundConfig.internalBinaryWrite(message.customNotificationSoundConfig, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  3464.     if (message.leaderboardsDisabled !== false)
  3465.       writer.tag(11, WireType.Varint).bool(message.leaderboardsDisabled);
  3466.     let u = options.writeUnknownFields;
  3467.     if (u !== false)
  3468.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3469.     return writer;
  3470.   }
  3471. }
  3472. var PreloadedUserSettings_GuildSettings = new PreloadedUserSettings_GuildSettings$Type;
  3473.  
  3474. class PreloadedUserSettings_AllGuildSettings$Type extends MessageType {
  3475.   constructor() {
  3476.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AllGuildSettings", [
  3477.       { no: 1, name: "guilds", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_GuildSettings } }
  3478.     ]);
  3479.   }
  3480.   create(value) {
  3481.     const message = globalThis.Object.create(this.messagePrototype);
  3482.     message.guilds = {};
  3483.     if (value !== undefined)
  3484.       reflectionMergePartial(this, message, value);
  3485.     return message;
  3486.   }
  3487.   internalBinaryRead(reader, length, options, target) {
  3488.     let message = target ?? this.create(), end = reader.pos + length;
  3489.     while (reader.pos < end) {
  3490.       let [fieldNo, wireType] = reader.tag();
  3491.       switch (fieldNo) {
  3492.         case 1:
  3493.           this.binaryReadMap1(message.guilds, reader, options);
  3494.           break;
  3495.         default:
  3496.           let u = options.readUnknownField;
  3497.           if (u === "throw")
  3498.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3499.           let d = reader.skip(wireType);
  3500.           if (u !== false)
  3501.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3502.       }
  3503.     }
  3504.     return message;
  3505.   }
  3506.   binaryReadMap1(map, reader, options) {
  3507.     let len = reader.uint32(), end = reader.pos + len, key, val;
  3508.     while (reader.pos < end) {
  3509.       let [fieldNo, wireType] = reader.tag();
  3510.       switch (fieldNo) {
  3511.         case 1:
  3512.           key = reader.fixed64().toString();
  3513.           break;
  3514.         case 2:
  3515.           val = PreloadedUserSettings_GuildSettings.internalBinaryRead(reader, reader.uint32(), options);
  3516.           break;
  3517.         default:
  3518.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.AllGuildSettings.guilds");
  3519.       }
  3520.     }
  3521.     map[key ?? "0"] = val ?? PreloadedUserSettings_GuildSettings.create();
  3522.   }
  3523.   internalBinaryWrite(message, writer, options) {
  3524.     for (let k of globalThis.Object.keys(message.guilds)) {
  3525.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  3526.       writer.tag(2, WireType.LengthDelimited).fork();
  3527.       PreloadedUserSettings_GuildSettings.internalBinaryWrite(message.guilds[k], writer, options);
  3528.       writer.join().join();
  3529.     }
  3530.     let u = options.writeUnknownFields;
  3531.     if (u !== false)
  3532.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3533.     return writer;
  3534.   }
  3535. }
  3536. var PreloadedUserSettings_AllGuildSettings = new PreloadedUserSettings_AllGuildSettings$Type;
  3537.  
  3538. class PreloadedUserSettings_RecurringDismissibleContentState$Type extends MessageType {
  3539.   constructor() {
  3540.     super("discord_protos.discord_users.v1.PreloadedUserSettings.RecurringDismissibleContentState", [
  3541.       { no: 1, name: "last_dismissed_version", kind: "scalar", T: 13 },
  3542.       { no: 2, name: "last_dismissed_at_ms", kind: "scalar", T: 4, L: 0 },
  3543.       { no: 3, name: "last_dismissed_object_id", kind: "scalar", T: 4, L: 0 }
  3544.     ]);
  3545.   }
  3546.   create(value) {
  3547.     const message = globalThis.Object.create(this.messagePrototype);
  3548.     message.lastDismissedVersion = 0;
  3549.     message.lastDismissedAtMs = 0n;
  3550.     message.lastDismissedObjectId = 0n;
  3551.     if (value !== undefined)
  3552.       reflectionMergePartial(this, message, value);
  3553.     return message;
  3554.   }
  3555.   internalBinaryRead(reader, length, options, target) {
  3556.     let message = target ?? this.create(), end = reader.pos + length;
  3557.     while (reader.pos < end) {
  3558.       let [fieldNo, wireType] = reader.tag();
  3559.       switch (fieldNo) {
  3560.         case 1:
  3561.           message.lastDismissedVersion = reader.uint32();
  3562.           break;
  3563.         case 2:
  3564.           message.lastDismissedAtMs = reader.uint64().toBigInt();
  3565.           break;
  3566.         case 3:
  3567.           message.lastDismissedObjectId = reader.uint64().toBigInt();
  3568.           break;
  3569.         default:
  3570.           let u = options.readUnknownField;
  3571.           if (u === "throw")
  3572.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3573.           let d = reader.skip(wireType);
  3574.           if (u !== false)
  3575.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3576.       }
  3577.     }
  3578.     return message;
  3579.   }
  3580.   internalBinaryWrite(message, writer, options) {
  3581.     if (message.lastDismissedVersion !== 0)
  3582.       writer.tag(1, WireType.Varint).uint32(message.lastDismissedVersion);
  3583.     if (message.lastDismissedAtMs !== 0n)
  3584.       writer.tag(2, WireType.Varint).uint64(message.lastDismissedAtMs);
  3585.     if (message.lastDismissedObjectId !== 0n)
  3586.       writer.tag(3, WireType.Varint).uint64(message.lastDismissedObjectId);
  3587.     let u = options.writeUnknownFields;
  3588.     if (u !== false)
  3589.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3590.     return writer;
  3591.   }
  3592. }
  3593. var PreloadedUserSettings_RecurringDismissibleContentState = new PreloadedUserSettings_RecurringDismissibleContentState$Type;
  3594.  
  3595. class PreloadedUserSettings_UserContentSettings$Type extends MessageType {
  3596.   constructor() {
  3597.     super("discord_protos.discord_users.v1.PreloadedUserSettings.UserContentSettings", [
  3598.       { no: 1, name: "dismissed_contents", kind: "scalar", T: 12 },
  3599.       { no: 2, name: "last_dismissed_outbound_promotion_start_date", kind: "message", T: () => StringValue },
  3600.       { no: 3, name: "premium_tier_0_modal_dismissed_at", kind: "message", T: () => Timestamp },
  3601.       { no: 4, name: "guild_onboarding_upsell_dismissed_at", kind: "message", T: () => Timestamp },
  3602.       { no: 5, name: "safety_user_sentiment_notice_dismissed_at", kind: "message", T: () => Timestamp },
  3603.       { no: 6, name: "last_received_changelog_id", kind: "scalar", T: 6, L: 0 },
  3604.       { no: 7, name: "recurring_dismissible_content_states", kind: "map", K: 5, V: { kind: "message", T: () => PreloadedUserSettings_RecurringDismissibleContentState } }
  3605.     ]);
  3606.   }
  3607.   create(value) {
  3608.     const message = globalThis.Object.create(this.messagePrototype);
  3609.     message.dismissedContents = new Uint8Array(0);
  3610.     message.lastReceivedChangelogId = 0n;
  3611.     message.recurringDismissibleContentStates = {};
  3612.     if (value !== undefined)
  3613.       reflectionMergePartial(this, message, value);
  3614.     return message;
  3615.   }
  3616.   internalBinaryRead(reader, length, options, target) {
  3617.     let message = target ?? this.create(), end = reader.pos + length;
  3618.     while (reader.pos < end) {
  3619.       let [fieldNo, wireType] = reader.tag();
  3620.       switch (fieldNo) {
  3621.         case 1:
  3622.           message.dismissedContents = reader.bytes();
  3623.           break;
  3624.         case 2:
  3625.           message.lastDismissedOutboundPromotionStartDate = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.lastDismissedOutboundPromotionStartDate);
  3626.           break;
  3627.         case 3:
  3628.           message.premiumTier0ModalDismissedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.premiumTier0ModalDismissedAt);
  3629.           break;
  3630.         case 4:
  3631.           message.guildOnboardingUpsellDismissedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.guildOnboardingUpsellDismissedAt);
  3632.           break;
  3633.         case 5:
  3634.           message.safetyUserSentimentNoticeDismissedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.safetyUserSentimentNoticeDismissedAt);
  3635.           break;
  3636.         case 6:
  3637.           message.lastReceivedChangelogId = reader.fixed64().toBigInt();
  3638.           break;
  3639.         case 7:
  3640.           this.binaryReadMap7(message.recurringDismissibleContentStates, reader, options);
  3641.           break;
  3642.         default:
  3643.           let u = options.readUnknownField;
  3644.           if (u === "throw")
  3645.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3646.           let d = reader.skip(wireType);
  3647.           if (u !== false)
  3648.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3649.       }
  3650.     }
  3651.     return message;
  3652.   }
  3653.   binaryReadMap7(map, reader, options) {
  3654.     let len = reader.uint32(), end = reader.pos + len, key, val;
  3655.     while (reader.pos < end) {
  3656.       let [fieldNo, wireType] = reader.tag();
  3657.       switch (fieldNo) {
  3658.         case 1:
  3659.           key = reader.int32();
  3660.           break;
  3661.         case 2:
  3662.           val = PreloadedUserSettings_RecurringDismissibleContentState.internalBinaryRead(reader, reader.uint32(), options);
  3663.           break;
  3664.         default:
  3665.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.UserContentSettings.recurring_dismissible_content_states");
  3666.       }
  3667.     }
  3668.     map[key ?? 0] = val ?? PreloadedUserSettings_RecurringDismissibleContentState.create();
  3669.   }
  3670.   internalBinaryWrite(message, writer, options) {
  3671.     if (message.dismissedContents.length)
  3672.       writer.tag(1, WireType.LengthDelimited).bytes(message.dismissedContents);
  3673.     if (message.lastDismissedOutboundPromotionStartDate)
  3674.       StringValue.internalBinaryWrite(message.lastDismissedOutboundPromotionStartDate, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  3675.     if (message.premiumTier0ModalDismissedAt)
  3676.       Timestamp.internalBinaryWrite(message.premiumTier0ModalDismissedAt, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  3677.     if (message.guildOnboardingUpsellDismissedAt)
  3678.       Timestamp.internalBinaryWrite(message.guildOnboardingUpsellDismissedAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  3679.     if (message.safetyUserSentimentNoticeDismissedAt)
  3680.       Timestamp.internalBinaryWrite(message.safetyUserSentimentNoticeDismissedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  3681.     if (message.lastReceivedChangelogId !== 0n)
  3682.       writer.tag(6, WireType.Bit64).fixed64(message.lastReceivedChangelogId);
  3683.     for (let k of globalThis.Object.keys(message.recurringDismissibleContentStates)) {
  3684.       writer.tag(7, WireType.LengthDelimited).fork().tag(1, WireType.Varint).int32(parseInt(k));
  3685.       writer.tag(2, WireType.LengthDelimited).fork();
  3686.       PreloadedUserSettings_RecurringDismissibleContentState.internalBinaryWrite(message.recurringDismissibleContentStates[k], writer, options);
  3687.       writer.join().join();
  3688.     }
  3689.     let u = options.writeUnknownFields;
  3690.     if (u !== false)
  3691.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3692.     return writer;
  3693.   }
  3694. }
  3695. var PreloadedUserSettings_UserContentSettings = new PreloadedUserSettings_UserContentSettings$Type;
  3696.  
  3697. class PreloadedUserSettings_VideoFilterBackgroundBlur$Type extends MessageType {
  3698.   constructor() {
  3699.     super("discord_protos.discord_users.v1.PreloadedUserSettings.VideoFilterBackgroundBlur", [
  3700.       { no: 1, name: "use_blur", kind: "scalar", T: 8 }
  3701.     ]);
  3702.   }
  3703.   create(value) {
  3704.     const message = globalThis.Object.create(this.messagePrototype);
  3705.     message.useBlur = false;
  3706.     if (value !== undefined)
  3707.       reflectionMergePartial(this, message, value);
  3708.     return message;
  3709.   }
  3710.   internalBinaryRead(reader, length, options, target) {
  3711.     let message = target ?? this.create(), end = reader.pos + length;
  3712.     while (reader.pos < end) {
  3713.       let [fieldNo, wireType] = reader.tag();
  3714.       switch (fieldNo) {
  3715.         case 1:
  3716.           message.useBlur = reader.bool();
  3717.           break;
  3718.         default:
  3719.           let u = options.readUnknownField;
  3720.           if (u === "throw")
  3721.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3722.           let d = reader.skip(wireType);
  3723.           if (u !== false)
  3724.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3725.       }
  3726.     }
  3727.     return message;
  3728.   }
  3729.   internalBinaryWrite(message, writer, options) {
  3730.     if (message.useBlur !== false)
  3731.       writer.tag(1, WireType.Varint).bool(message.useBlur);
  3732.     let u = options.writeUnknownFields;
  3733.     if (u !== false)
  3734.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3735.     return writer;
  3736.   }
  3737. }
  3738. var PreloadedUserSettings_VideoFilterBackgroundBlur = new PreloadedUserSettings_VideoFilterBackgroundBlur$Type;
  3739.  
  3740. class PreloadedUserSettings_VideoFilterAsset$Type extends MessageType {
  3741.   constructor() {
  3742.     super("discord_protos.discord_users.v1.PreloadedUserSettings.VideoFilterAsset", [
  3743.       { no: 1, name: "id", kind: "scalar", T: 6, L: 0 },
  3744.       { no: 2, name: "asset_hash", kind: "scalar", T: 9 }
  3745.     ]);
  3746.   }
  3747.   create(value) {
  3748.     const message = globalThis.Object.create(this.messagePrototype);
  3749.     message.id = 0n;
  3750.     message.assetHash = "";
  3751.     if (value !== undefined)
  3752.       reflectionMergePartial(this, message, value);
  3753.     return message;
  3754.   }
  3755.   internalBinaryRead(reader, length, options, target) {
  3756.     let message = target ?? this.create(), end = reader.pos + length;
  3757.     while (reader.pos < end) {
  3758.       let [fieldNo, wireType] = reader.tag();
  3759.       switch (fieldNo) {
  3760.         case 1:
  3761.           message.id = reader.fixed64().toBigInt();
  3762.           break;
  3763.         case 2:
  3764.           message.assetHash = reader.string();
  3765.           break;
  3766.         default:
  3767.           let u = options.readUnknownField;
  3768.           if (u === "throw")
  3769.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3770.           let d = reader.skip(wireType);
  3771.           if (u !== false)
  3772.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3773.       }
  3774.     }
  3775.     return message;
  3776.   }
  3777.   internalBinaryWrite(message, writer, options) {
  3778.     if (message.id !== 0n)
  3779.       writer.tag(1, WireType.Bit64).fixed64(message.id);
  3780.     if (message.assetHash !== "")
  3781.       writer.tag(2, WireType.LengthDelimited).string(message.assetHash);
  3782.     let u = options.writeUnknownFields;
  3783.     if (u !== false)
  3784.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3785.     return writer;
  3786.   }
  3787. }
  3788. var PreloadedUserSettings_VideoFilterAsset = new PreloadedUserSettings_VideoFilterAsset$Type;
  3789.  
  3790. class PreloadedUserSettings_SoundboardSettings$Type extends MessageType {
  3791.   constructor() {
  3792.     super("discord_protos.discord_users.v1.PreloadedUserSettings.SoundboardSettings", [
  3793.       { no: 1, name: "volume", kind: "scalar", T: 2 }
  3794.     ]);
  3795.   }
  3796.   create(value) {
  3797.     const message = globalThis.Object.create(this.messagePrototype);
  3798.     message.volume = 0;
  3799.     if (value !== undefined)
  3800.       reflectionMergePartial(this, message, value);
  3801.     return message;
  3802.   }
  3803.   internalBinaryRead(reader, length, options, target) {
  3804.     let message = target ?? this.create(), end = reader.pos + length;
  3805.     while (reader.pos < end) {
  3806.       let [fieldNo, wireType] = reader.tag();
  3807.       switch (fieldNo) {
  3808.         case 1:
  3809.           message.volume = reader.float();
  3810.           break;
  3811.         default:
  3812.           let u = options.readUnknownField;
  3813.           if (u === "throw")
  3814.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3815.           let d = reader.skip(wireType);
  3816.           if (u !== false)
  3817.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3818.       }
  3819.     }
  3820.     return message;
  3821.   }
  3822.   internalBinaryWrite(message, writer, options) {
  3823.     if (message.volume !== 0)
  3824.       writer.tag(1, WireType.Bit32).float(message.volume);
  3825.     let u = options.writeUnknownFields;
  3826.     if (u !== false)
  3827.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3828.     return writer;
  3829.   }
  3830. }
  3831. var PreloadedUserSettings_SoundboardSettings = new PreloadedUserSettings_SoundboardSettings$Type;
  3832.  
  3833. class PreloadedUserSettings_VoiceAndVideoSettings$Type extends MessageType {
  3834.   constructor() {
  3835.     super("discord_protos.discord_users.v1.PreloadedUserSettings.VoiceAndVideoSettings", [
  3836.       { no: 1, name: "blur", kind: "message", oneof: "videoBackgroundFilterDesktop", T: () => PreloadedUserSettings_VideoFilterBackgroundBlur },
  3837.       { no: 2, name: "preset_option", kind: "scalar", oneof: "videoBackgroundFilterDesktop", T: 13 },
  3838.       { no: 3, name: "custom_asset", kind: "message", oneof: "videoBackgroundFilterDesktop", T: () => PreloadedUserSettings_VideoFilterAsset },
  3839.       { no: 5, name: "always_preview_video", kind: "message", T: () => BoolValue },
  3840.       { no: 6, name: "afk_timeout", kind: "message", T: () => UInt32Value },
  3841.       { no: 7, name: "stream_notifications_enabled", kind: "message", T: () => BoolValue },
  3842.       { no: 8, name: "native_phone_integration_enabled", kind: "message", T: () => BoolValue },
  3843.       { no: 9, name: "soundboard_settings", kind: "message", T: () => PreloadedUserSettings_SoundboardSettings },
  3844.       { no: 10, name: "disable_stream_previews", kind: "message", T: () => BoolValue },
  3845.       { no: 11, name: "soundmoji_volume", kind: "message", T: () => FloatValue }
  3846.     ]);
  3847.   }
  3848.   create(value) {
  3849.     const message = globalThis.Object.create(this.messagePrototype);
  3850.     message.videoBackgroundFilterDesktop = { oneofKind: undefined };
  3851.     if (value !== undefined)
  3852.       reflectionMergePartial(this, message, value);
  3853.     return message;
  3854.   }
  3855.   internalBinaryRead(reader, length, options, target) {
  3856.     let message = target ?? this.create(), end = reader.pos + length;
  3857.     while (reader.pos < end) {
  3858.       let [fieldNo, wireType] = reader.tag();
  3859.       switch (fieldNo) {
  3860.         case 1:
  3861.           message.videoBackgroundFilterDesktop = {
  3862.             oneofKind: "blur",
  3863.             blur: PreloadedUserSettings_VideoFilterBackgroundBlur.internalBinaryRead(reader, reader.uint32(), options, message.videoBackgroundFilterDesktop.blur)
  3864.           };
  3865.           break;
  3866.         case 2:
  3867.           message.videoBackgroundFilterDesktop = {
  3868.             oneofKind: "presetOption",
  3869.             presetOption: reader.uint32()
  3870.           };
  3871.           break;
  3872.         case 3:
  3873.           message.videoBackgroundFilterDesktop = {
  3874.             oneofKind: "customAsset",
  3875.             customAsset: PreloadedUserSettings_VideoFilterAsset.internalBinaryRead(reader, reader.uint32(), options, message.videoBackgroundFilterDesktop.customAsset)
  3876.           };
  3877.           break;
  3878.         case 5:
  3879.           message.alwaysPreviewVideo = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.alwaysPreviewVideo);
  3880.           break;
  3881.         case 6:
  3882.           message.afkTimeout = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.afkTimeout);
  3883.           break;
  3884.         case 7:
  3885.           message.streamNotificationsEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.streamNotificationsEnabled);
  3886.           break;
  3887.         case 8:
  3888.           message.nativePhoneIntegrationEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.nativePhoneIntegrationEnabled);
  3889.           break;
  3890.         case 9:
  3891.           message.soundboardSettings = PreloadedUserSettings_SoundboardSettings.internalBinaryRead(reader, reader.uint32(), options, message.soundboardSettings);
  3892.           break;
  3893.         case 10:
  3894.           message.disableStreamPreviews = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.disableStreamPreviews);
  3895.           break;
  3896.         case 11:
  3897.           message.soundmojiVolume = FloatValue.internalBinaryRead(reader, reader.uint32(), options, message.soundmojiVolume);
  3898.           break;
  3899.         default:
  3900.           let u = options.readUnknownField;
  3901.           if (u === "throw")
  3902.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3903.           let d = reader.skip(wireType);
  3904.           if (u !== false)
  3905.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3906.       }
  3907.     }
  3908.     return message;
  3909.   }
  3910.   internalBinaryWrite(message, writer, options) {
  3911.     if (message.videoBackgroundFilterDesktop.oneofKind === "blur")
  3912.       PreloadedUserSettings_VideoFilterBackgroundBlur.internalBinaryWrite(message.videoBackgroundFilterDesktop.blur, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  3913.     if (message.videoBackgroundFilterDesktop.oneofKind === "presetOption")
  3914.       writer.tag(2, WireType.Varint).uint32(message.videoBackgroundFilterDesktop.presetOption);
  3915.     if (message.videoBackgroundFilterDesktop.oneofKind === "customAsset")
  3916.       PreloadedUserSettings_VideoFilterAsset.internalBinaryWrite(message.videoBackgroundFilterDesktop.customAsset, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  3917.     if (message.alwaysPreviewVideo)
  3918.       BoolValue.internalBinaryWrite(message.alwaysPreviewVideo, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  3919.     if (message.afkTimeout)
  3920.       UInt32Value.internalBinaryWrite(message.afkTimeout, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  3921.     if (message.streamNotificationsEnabled)
  3922.       BoolValue.internalBinaryWrite(message.streamNotificationsEnabled, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  3923.     if (message.nativePhoneIntegrationEnabled)
  3924.       BoolValue.internalBinaryWrite(message.nativePhoneIntegrationEnabled, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  3925.     if (message.soundboardSettings)
  3926.       PreloadedUserSettings_SoundboardSettings.internalBinaryWrite(message.soundboardSettings, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  3927.     if (message.disableStreamPreviews)
  3928.       BoolValue.internalBinaryWrite(message.disableStreamPreviews, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  3929.     if (message.soundmojiVolume)
  3930.       FloatValue.internalBinaryWrite(message.soundmojiVolume, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  3931.     let u = options.writeUnknownFields;
  3932.     if (u !== false)
  3933.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3934.     return writer;
  3935.   }
  3936. }
  3937. var PreloadedUserSettings_VoiceAndVideoSettings = new PreloadedUserSettings_VoiceAndVideoSettings$Type;
  3938.  
  3939. class PreloadedUserSettings_ExplicitContentSettings$Type extends MessageType {
  3940.   constructor() {
  3941.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ExplicitContentSettings", [
  3942.       { no: 1, name: "explicit_content_guilds", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.ExplicitContentRedaction", PreloadedUserSettings_ExplicitContentRedaction, "EXPLICIT_CONTENT_REDACTION_"] },
  3943.       { no: 2, name: "explicit_content_friend_dm", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.ExplicitContentRedaction", PreloadedUserSettings_ExplicitContentRedaction, "EXPLICIT_CONTENT_REDACTION_"] },
  3944.       { no: 3, name: "explicit_content_non_friend_dm", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.ExplicitContentRedaction", PreloadedUserSettings_ExplicitContentRedaction, "EXPLICIT_CONTENT_REDACTION_"] }
  3945.     ]);
  3946.   }
  3947.   create(value) {
  3948.     const message = globalThis.Object.create(this.messagePrototype);
  3949.     message.explicitContentGuilds = 0;
  3950.     message.explicitContentFriendDm = 0;
  3951.     message.explicitContentNonFriendDm = 0;
  3952.     if (value !== undefined)
  3953.       reflectionMergePartial(this, message, value);
  3954.     return message;
  3955.   }
  3956.   internalBinaryRead(reader, length, options, target) {
  3957.     let message = target ?? this.create(), end = reader.pos + length;
  3958.     while (reader.pos < end) {
  3959.       let [fieldNo, wireType] = reader.tag();
  3960.       switch (fieldNo) {
  3961.         case 1:
  3962.           message.explicitContentGuilds = reader.int32();
  3963.           break;
  3964.         case 2:
  3965.           message.explicitContentFriendDm = reader.int32();
  3966.           break;
  3967.         case 3:
  3968.           message.explicitContentNonFriendDm = reader.int32();
  3969.           break;
  3970.         default:
  3971.           let u = options.readUnknownField;
  3972.           if (u === "throw")
  3973.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  3974.           let d = reader.skip(wireType);
  3975.           if (u !== false)
  3976.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  3977.       }
  3978.     }
  3979.     return message;
  3980.   }
  3981.   internalBinaryWrite(message, writer, options) {
  3982.     if (message.explicitContentGuilds !== 0)
  3983.       writer.tag(1, WireType.Varint).int32(message.explicitContentGuilds);
  3984.     if (message.explicitContentFriendDm !== 0)
  3985.       writer.tag(2, WireType.Varint).int32(message.explicitContentFriendDm);
  3986.     if (message.explicitContentNonFriendDm !== 0)
  3987.       writer.tag(3, WireType.Varint).int32(message.explicitContentNonFriendDm);
  3988.     let u = options.writeUnknownFields;
  3989.     if (u !== false)
  3990.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  3991.     return writer;
  3992.   }
  3993. }
  3994. var PreloadedUserSettings_ExplicitContentSettings = new PreloadedUserSettings_ExplicitContentSettings$Type;
  3995.  
  3996. class PreloadedUserSettings_KeywordFilterSettings$Type extends MessageType {
  3997.   constructor() {
  3998.     super("discord_protos.discord_users.v1.PreloadedUserSettings.KeywordFilterSettings", [
  3999.       { no: 1, name: "profanity", kind: "message", T: () => BoolValue },
  4000.       { no: 2, name: "sexual_content", kind: "message", T: () => BoolValue },
  4001.       { no: 3, name: "slurs", kind: "message", T: () => BoolValue }
  4002.     ]);
  4003.   }
  4004.   create(value) {
  4005.     const message = globalThis.Object.create(this.messagePrototype);
  4006.     if (value !== undefined)
  4007.       reflectionMergePartial(this, message, value);
  4008.     return message;
  4009.   }
  4010.   internalBinaryRead(reader, length, options, target) {
  4011.     let message = target ?? this.create(), end = reader.pos + length;
  4012.     while (reader.pos < end) {
  4013.       let [fieldNo, wireType] = reader.tag();
  4014.       switch (fieldNo) {
  4015.         case 1:
  4016.           message.profanity = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.profanity);
  4017.           break;
  4018.         case 2:
  4019.           message.sexualContent = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.sexualContent);
  4020.           break;
  4021.         case 3:
  4022.           message.slurs = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.slurs);
  4023.           break;
  4024.         default:
  4025.           let u = options.readUnknownField;
  4026.           if (u === "throw")
  4027.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4028.           let d = reader.skip(wireType);
  4029.           if (u !== false)
  4030.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4031.       }
  4032.     }
  4033.     return message;
  4034.   }
  4035.   internalBinaryWrite(message, writer, options) {
  4036.     if (message.profanity)
  4037.       BoolValue.internalBinaryWrite(message.profanity, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4038.     if (message.sexualContent)
  4039.       BoolValue.internalBinaryWrite(message.sexualContent, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4040.     if (message.slurs)
  4041.       BoolValue.internalBinaryWrite(message.slurs, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  4042.     let u = options.writeUnknownFields;
  4043.     if (u !== false)
  4044.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4045.     return writer;
  4046.   }
  4047. }
  4048. var PreloadedUserSettings_KeywordFilterSettings = new PreloadedUserSettings_KeywordFilterSettings$Type;
  4049.  
  4050. class PreloadedUserSettings_TextAndImagesSettings$Type extends MessageType {
  4051.   constructor() {
  4052.     super("discord_protos.discord_users.v1.PreloadedUserSettings.TextAndImagesSettings", [
  4053.       { no: 1, name: "diversity_surrogate", kind: "message", T: () => StringValue },
  4054.       { no: 2, name: "use_rich_chat_input", kind: "message", T: () => BoolValue },
  4055.       { no: 3, name: "use_thread_sidebar", kind: "message", T: () => BoolValue },
  4056.       { no: 4, name: "render_spoilers", kind: "message", T: () => StringValue },
  4057.       { no: 5, name: "emoji_picker_collapsed_sections", kind: "scalar", repeat: 2, T: 9 },
  4058.       { no: 6, name: "sticker_picker_collapsed_sections", kind: "scalar", repeat: 2, T: 9 },
  4059.       { no: 7, name: "view_image_descriptions", kind: "message", T: () => BoolValue },
  4060.       { no: 8, name: "show_command_suggestions", kind: "message", T: () => BoolValue },
  4061.       { no: 9, name: "inline_attachment_media", kind: "message", T: () => BoolValue },
  4062.       { no: 10, name: "inline_embed_media", kind: "message", T: () => BoolValue },
  4063.       { no: 11, name: "gif_auto_play", kind: "message", T: () => BoolValue },
  4064.       { no: 12, name: "render_embeds", kind: "message", T: () => BoolValue },
  4065.       { no: 13, name: "render_reactions", kind: "message", T: () => BoolValue },
  4066.       { no: 14, name: "animate_emoji", kind: "message", T: () => BoolValue },
  4067.       { no: 15, name: "animate_stickers", kind: "message", T: () => UInt32Value },
  4068.       { no: 16, name: "enable_tts_command", kind: "message", T: () => BoolValue },
  4069.       { no: 17, name: "message_display_compact", kind: "message", T: () => BoolValue },
  4070.       { no: 19, name: "explicit_content_filter", kind: "message", T: () => UInt32Value },
  4071.       { no: 20, name: "view_nsfw_guilds", kind: "message", T: () => BoolValue },
  4072.       { no: 21, name: "convert_emoticons", kind: "message", T: () => BoolValue },
  4073.       { no: 22, name: "expression_suggestions_enabled", kind: "message", T: () => BoolValue },
  4074.       { no: 23, name: "view_nsfw_commands", kind: "message", T: () => BoolValue },
  4075.       { no: 24, name: "use_legacy_chat_input", kind: "message", T: () => BoolValue },
  4076.       { no: 25, name: "soundboard_picker_collapsed_sections", kind: "scalar", repeat: 2, T: 9 },
  4077.       { no: 26, name: "dm_spam_filter", kind: "message", T: () => UInt32Value },
  4078.       { no: 27, name: "dm_spam_filter_v2", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.DmSpamFilterV2", PreloadedUserSettings_DmSpamFilterV2, "DM_SPAM_FILTER_V2_"] },
  4079.       { no: 28, name: "include_stickers_in_autocomplete", kind: "message", T: () => BoolValue },
  4080.       { no: 29, name: "explicit_content_settings", kind: "message", T: () => PreloadedUserSettings_ExplicitContentSettings },
  4081.       { no: 30, name: "keyword_filter_settings", kind: "message", T: () => PreloadedUserSettings_KeywordFilterSettings },
  4082.       { no: 31, name: "include_soundmoji_in_autocomplete", kind: "message", T: () => BoolValue }
  4083.     ]);
  4084.   }
  4085.   create(value) {
  4086.     const message = globalThis.Object.create(this.messagePrototype);
  4087.     message.emojiPickerCollapsedSections = [];
  4088.     message.stickerPickerCollapsedSections = [];
  4089.     message.soundboardPickerCollapsedSections = [];
  4090.     message.dmSpamFilterV2 = 0;
  4091.     if (value !== undefined)
  4092.       reflectionMergePartial(this, message, value);
  4093.     return message;
  4094.   }
  4095.   internalBinaryRead(reader, length, options, target) {
  4096.     let message = target ?? this.create(), end = reader.pos + length;
  4097.     while (reader.pos < end) {
  4098.       let [fieldNo, wireType] = reader.tag();
  4099.       switch (fieldNo) {
  4100.         case 1:
  4101.           message.diversitySurrogate = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.diversitySurrogate);
  4102.           break;
  4103.         case 2:
  4104.           message.useRichChatInput = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.useRichChatInput);
  4105.           break;
  4106.         case 3:
  4107.           message.useThreadSidebar = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.useThreadSidebar);
  4108.           break;
  4109.         case 4:
  4110.           message.renderSpoilers = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.renderSpoilers);
  4111.           break;
  4112.         case 5:
  4113.           message.emojiPickerCollapsedSections.push(reader.string());
  4114.           break;
  4115.         case 6:
  4116.           message.stickerPickerCollapsedSections.push(reader.string());
  4117.           break;
  4118.         case 7:
  4119.           message.viewImageDescriptions = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.viewImageDescriptions);
  4120.           break;
  4121.         case 8:
  4122.           message.showCommandSuggestions = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.showCommandSuggestions);
  4123.           break;
  4124.         case 9:
  4125.           message.inlineAttachmentMedia = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.inlineAttachmentMedia);
  4126.           break;
  4127.         case 10:
  4128.           message.inlineEmbedMedia = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.inlineEmbedMedia);
  4129.           break;
  4130.         case 11:
  4131.           message.gifAutoPlay = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.gifAutoPlay);
  4132.           break;
  4133.         case 12:
  4134.           message.renderEmbeds = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.renderEmbeds);
  4135.           break;
  4136.         case 13:
  4137.           message.renderReactions = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.renderReactions);
  4138.           break;
  4139.         case 14:
  4140.           message.animateEmoji = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.animateEmoji);
  4141.           break;
  4142.         case 15:
  4143.           message.animateStickers = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.animateStickers);
  4144.           break;
  4145.         case 16:
  4146.           message.enableTtsCommand = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.enableTtsCommand);
  4147.           break;
  4148.         case 17:
  4149.           message.messageDisplayCompact = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.messageDisplayCompact);
  4150.           break;
  4151.         case 19:
  4152.           message.explicitContentFilter = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.explicitContentFilter);
  4153.           break;
  4154.         case 20:
  4155.           message.viewNsfwGuilds = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.viewNsfwGuilds);
  4156.           break;
  4157.         case 21:
  4158.           message.convertEmoticons = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.convertEmoticons);
  4159.           break;
  4160.         case 22:
  4161.           message.expressionSuggestionsEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.expressionSuggestionsEnabled);
  4162.           break;
  4163.         case 23:
  4164.           message.viewNsfwCommands = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.viewNsfwCommands);
  4165.           break;
  4166.         case 24:
  4167.           message.useLegacyChatInput = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.useLegacyChatInput);
  4168.           break;
  4169.         case 25:
  4170.           message.soundboardPickerCollapsedSections.push(reader.string());
  4171.           break;
  4172.         case 26:
  4173.           message.dmSpamFilter = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.dmSpamFilter);
  4174.           break;
  4175.         case 27:
  4176.           message.dmSpamFilterV2 = reader.int32();
  4177.           break;
  4178.         case 28:
  4179.           message.includeStickersInAutocomplete = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.includeStickersInAutocomplete);
  4180.           break;
  4181.         case 29:
  4182.           message.explicitContentSettings = PreloadedUserSettings_ExplicitContentSettings.internalBinaryRead(reader, reader.uint32(), options, message.explicitContentSettings);
  4183.           break;
  4184.         case 30:
  4185.           message.keywordFilterSettings = PreloadedUserSettings_KeywordFilterSettings.internalBinaryRead(reader, reader.uint32(), options, message.keywordFilterSettings);
  4186.           break;
  4187.         case 31:
  4188.           message.includeSoundmojiInAutocomplete = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.includeSoundmojiInAutocomplete);
  4189.           break;
  4190.         default:
  4191.           let u = options.readUnknownField;
  4192.           if (u === "throw")
  4193.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4194.           let d = reader.skip(wireType);
  4195.           if (u !== false)
  4196.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4197.       }
  4198.     }
  4199.     return message;
  4200.   }
  4201.   internalBinaryWrite(message, writer, options) {
  4202.     if (message.diversitySurrogate)
  4203.       StringValue.internalBinaryWrite(message.diversitySurrogate, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4204.     if (message.useRichChatInput)
  4205.       BoolValue.internalBinaryWrite(message.useRichChatInput, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4206.     if (message.useThreadSidebar)
  4207.       BoolValue.internalBinaryWrite(message.useThreadSidebar, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  4208.     if (message.renderSpoilers)
  4209.       StringValue.internalBinaryWrite(message.renderSpoilers, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  4210.     for (let i = 0;i < message.emojiPickerCollapsedSections.length; i++)
  4211.       writer.tag(5, WireType.LengthDelimited).string(message.emojiPickerCollapsedSections[i]);
  4212.     for (let i = 0;i < message.stickerPickerCollapsedSections.length; i++)
  4213.       writer.tag(6, WireType.LengthDelimited).string(message.stickerPickerCollapsedSections[i]);
  4214.     if (message.viewImageDescriptions)
  4215.       BoolValue.internalBinaryWrite(message.viewImageDescriptions, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  4216.     if (message.showCommandSuggestions)
  4217.       BoolValue.internalBinaryWrite(message.showCommandSuggestions, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  4218.     if (message.inlineAttachmentMedia)
  4219.       BoolValue.internalBinaryWrite(message.inlineAttachmentMedia, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  4220.     if (message.inlineEmbedMedia)
  4221.       BoolValue.internalBinaryWrite(message.inlineEmbedMedia, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  4222.     if (message.gifAutoPlay)
  4223.       BoolValue.internalBinaryWrite(message.gifAutoPlay, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  4224.     if (message.renderEmbeds)
  4225.       BoolValue.internalBinaryWrite(message.renderEmbeds, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
  4226.     if (message.renderReactions)
  4227.       BoolValue.internalBinaryWrite(message.renderReactions, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
  4228.     if (message.animateEmoji)
  4229.       BoolValue.internalBinaryWrite(message.animateEmoji, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
  4230.     if (message.animateStickers)
  4231.       UInt32Value.internalBinaryWrite(message.animateStickers, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
  4232.     if (message.enableTtsCommand)
  4233.       BoolValue.internalBinaryWrite(message.enableTtsCommand, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
  4234.     if (message.messageDisplayCompact)
  4235.       BoolValue.internalBinaryWrite(message.messageDisplayCompact, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
  4236.     if (message.explicitContentFilter)
  4237.       UInt32Value.internalBinaryWrite(message.explicitContentFilter, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
  4238.     if (message.viewNsfwGuilds)
  4239.       BoolValue.internalBinaryWrite(message.viewNsfwGuilds, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
  4240.     if (message.convertEmoticons)
  4241.       BoolValue.internalBinaryWrite(message.convertEmoticons, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
  4242.     if (message.expressionSuggestionsEnabled)
  4243.       BoolValue.internalBinaryWrite(message.expressionSuggestionsEnabled, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
  4244.     if (message.viewNsfwCommands)
  4245.       BoolValue.internalBinaryWrite(message.viewNsfwCommands, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
  4246.     if (message.useLegacyChatInput)
  4247.       BoolValue.internalBinaryWrite(message.useLegacyChatInput, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
  4248.     for (let i = 0;i < message.soundboardPickerCollapsedSections.length; i++)
  4249.       writer.tag(25, WireType.LengthDelimited).string(message.soundboardPickerCollapsedSections[i]);
  4250.     if (message.dmSpamFilter)
  4251.       UInt32Value.internalBinaryWrite(message.dmSpamFilter, writer.tag(26, WireType.LengthDelimited).fork(), options).join();
  4252.     if (message.dmSpamFilterV2 !== 0)
  4253.       writer.tag(27, WireType.Varint).int32(message.dmSpamFilterV2);
  4254.     if (message.includeStickersInAutocomplete)
  4255.       BoolValue.internalBinaryWrite(message.includeStickersInAutocomplete, writer.tag(28, WireType.LengthDelimited).fork(), options).join();
  4256.     if (message.explicitContentSettings)
  4257.       PreloadedUserSettings_ExplicitContentSettings.internalBinaryWrite(message.explicitContentSettings, writer.tag(29, WireType.LengthDelimited).fork(), options).join();
  4258.     if (message.keywordFilterSettings)
  4259.       PreloadedUserSettings_KeywordFilterSettings.internalBinaryWrite(message.keywordFilterSettings, writer.tag(30, WireType.LengthDelimited).fork(), options).join();
  4260.     if (message.includeSoundmojiInAutocomplete)
  4261.       BoolValue.internalBinaryWrite(message.includeSoundmojiInAutocomplete, writer.tag(31, WireType.LengthDelimited).fork(), options).join();
  4262.     let u = options.writeUnknownFields;
  4263.     if (u !== false)
  4264.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4265.     return writer;
  4266.   }
  4267. }
  4268. var PreloadedUserSettings_TextAndImagesSettings = new PreloadedUserSettings_TextAndImagesSettings$Type;
  4269.  
  4270. class PreloadedUserSettings_NotificationSettings$Type extends MessageType {
  4271.   constructor() {
  4272.     super("discord_protos.discord_users.v1.PreloadedUserSettings.NotificationSettings", [
  4273.       { no: 1, name: "show_in_app_notifications", kind: "message", T: () => BoolValue },
  4274.       { no: 2, name: "notify_friends_on_go_live", kind: "message", T: () => BoolValue },
  4275.       { no: 3, name: "notification_center_acked_before_id", kind: "scalar", T: 6, L: 0 },
  4276.       { no: 4, name: "enable_burst_reaction_notifications", kind: "message", T: () => BoolValue },
  4277.       { no: 5, name: "quiet_mode", kind: "message", T: () => BoolValue },
  4278.       { no: 6, name: "focus_mode_expires_at_ms", kind: "scalar", T: 6, L: 0 },
  4279.       { no: 7, name: "reaction_notifications", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.ReactionNotificationType", PreloadedUserSettings_ReactionNotificationType, "REACTION_NOTIFICATION_TYPE_"] }
  4280.     ]);
  4281.   }
  4282.   create(value) {
  4283.     const message = globalThis.Object.create(this.messagePrototype);
  4284.     message.notificationCenterAckedBeforeId = 0n;
  4285.     message.focusModeExpiresAtMs = 0n;
  4286.     message.reactionNotifications = 0;
  4287.     if (value !== undefined)
  4288.       reflectionMergePartial(this, message, value);
  4289.     return message;
  4290.   }
  4291.   internalBinaryRead(reader, length, options, target) {
  4292.     let message = target ?? this.create(), end = reader.pos + length;
  4293.     while (reader.pos < end) {
  4294.       let [fieldNo, wireType] = reader.tag();
  4295.       switch (fieldNo) {
  4296.         case 1:
  4297.           message.showInAppNotifications = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.showInAppNotifications);
  4298.           break;
  4299.         case 2:
  4300.           message.notifyFriendsOnGoLive = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.notifyFriendsOnGoLive);
  4301.           break;
  4302.         case 3:
  4303.           message.notificationCenterAckedBeforeId = reader.fixed64().toBigInt();
  4304.           break;
  4305.         case 4:
  4306.           message.enableBurstReactionNotifications = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.enableBurstReactionNotifications);
  4307.           break;
  4308.         case 5:
  4309.           message.quietMode = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.quietMode);
  4310.           break;
  4311.         case 6:
  4312.           message.focusModeExpiresAtMs = reader.fixed64().toBigInt();
  4313.           break;
  4314.         case 7:
  4315.           message.reactionNotifications = reader.int32();
  4316.           break;
  4317.         default:
  4318.           let u = options.readUnknownField;
  4319.           if (u === "throw")
  4320.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4321.           let d = reader.skip(wireType);
  4322.           if (u !== false)
  4323.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4324.       }
  4325.     }
  4326.     return message;
  4327.   }
  4328.   internalBinaryWrite(message, writer, options) {
  4329.     if (message.showInAppNotifications)
  4330.       BoolValue.internalBinaryWrite(message.showInAppNotifications, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4331.     if (message.notifyFriendsOnGoLive)
  4332.       BoolValue.internalBinaryWrite(message.notifyFriendsOnGoLive, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4333.     if (message.notificationCenterAckedBeforeId !== 0n)
  4334.       writer.tag(3, WireType.Bit64).fixed64(message.notificationCenterAckedBeforeId);
  4335.     if (message.enableBurstReactionNotifications)
  4336.       BoolValue.internalBinaryWrite(message.enableBurstReactionNotifications, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  4337.     if (message.quietMode)
  4338.       BoolValue.internalBinaryWrite(message.quietMode, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  4339.     if (message.focusModeExpiresAtMs !== 0n)
  4340.       writer.tag(6, WireType.Bit64).fixed64(message.focusModeExpiresAtMs);
  4341.     if (message.reactionNotifications !== 0)
  4342.       writer.tag(7, WireType.Varint).int32(message.reactionNotifications);
  4343.     let u = options.writeUnknownFields;
  4344.     if (u !== false)
  4345.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4346.     return writer;
  4347.   }
  4348. }
  4349. var PreloadedUserSettings_NotificationSettings = new PreloadedUserSettings_NotificationSettings$Type;
  4350.  
  4351. class PreloadedUserSettings_PrivacySettings$Type extends MessageType {
  4352.   constructor() {
  4353.     super("discord_protos.discord_users.v1.PreloadedUserSettings.PrivacySettings", [
  4354.       { no: 1, name: "allow_activity_party_privacy_friends", kind: "message", T: () => BoolValue },
  4355.       { no: 2, name: "allow_activity_party_privacy_voice_channel", kind: "message", T: () => BoolValue },
  4356.       { no: 3, name: "restricted_guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  4357.       { no: 4, name: "default_guilds_restricted", kind: "scalar", T: 8 },
  4358.       { no: 7, name: "allow_accessibility_detection", kind: "scalar", T: 8 },
  4359.       { no: 8, name: "detect_platform_accounts", kind: "message", T: () => BoolValue },
  4360.       { no: 9, name: "passwordless", kind: "message", T: () => BoolValue },
  4361.       { no: 10, name: "contact_sync_enabled", kind: "message", T: () => BoolValue },
  4362.       { no: 11, name: "friend_source_flags", kind: "message", T: () => UInt32Value },
  4363.       { no: 12, name: "friend_discovery_flags", kind: "message", T: () => UInt32Value },
  4364.       { no: 13, name: "activity_restricted_guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  4365.       { no: 14, name: "default_guilds_activity_restricted", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.GuildActivityStatusRestrictionDefault", PreloadedUserSettings_GuildActivityStatusRestrictionDefault, "GUILD_ACTIVITY_STATUS_RESTRICTION_DEFAULT_"] },
  4366.       { no: 15, name: "activity_joining_restricted_guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  4367.       { no: 16, name: "message_request_restricted_guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  4368.       { no: 17, name: "default_message_request_restricted", kind: "message", T: () => BoolValue },
  4369.       { no: 18, name: "drops_opted_out", kind: "message", T: () => BoolValue },
  4370.       { no: 19, name: "non_spam_retraining_opt_in", kind: "message", T: () => BoolValue },
  4371.       { no: 20, name: "family_center_enabled", kind: "message", T: () => BoolValue },
  4372.       { no: 21, name: "family_center_enabled_v2", kind: "message", T: () => BoolValue },
  4373.       { no: 22, name: "hide_legacy_username", kind: "message", T: () => BoolValue },
  4374.       { no: 23, name: "inappropriate_conversation_warnings", kind: "message", T: () => BoolValue },
  4375.       { no: 24, name: "recent_games_enabled", kind: "message", T: () => BoolValue },
  4376.       { no: 25, name: "guilds_leaderboard_opt_out_default", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.GuildsLeaderboardOptOutDefault", PreloadedUserSettings_GuildsLeaderboardOptOutDefault, "GUILDS_LEADERBOARD_OPT_OUT_DEFAULT_"] },
  4377.       { no: 26, name: "allow_game_friend_dms_in_discord", kind: "message", T: () => BoolValue },
  4378.       { no: 27, name: "default_guilds_restricted_v2", kind: "message", T: () => BoolValue },
  4379.       { no: 28, name: "slayer_sdk_receive_dms_in_game", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.SlayerSDKReceiveInGameDMs", PreloadedUserSettings_SlayerSDKReceiveInGameDMs] }
  4380.     ]);
  4381.   }
  4382.   create(value) {
  4383.     const message = globalThis.Object.create(this.messagePrototype);
  4384.     message.restrictedGuildIds = [];
  4385.     message.defaultGuildsRestricted = false;
  4386.     message.allowAccessibilityDetection = false;
  4387.     message.activityRestrictedGuildIds = [];
  4388.     message.defaultGuildsActivityRestricted = 0;
  4389.     message.activityJoiningRestrictedGuildIds = [];
  4390.     message.messageRequestRestrictedGuildIds = [];
  4391.     message.guildsLeaderboardOptOutDefault = 0;
  4392.     message.slayerSdkReceiveDmsInGame = 0;
  4393.     if (value !== undefined)
  4394.       reflectionMergePartial(this, message, value);
  4395.     return message;
  4396.   }
  4397.   internalBinaryRead(reader, length, options, target) {
  4398.     let message = target ?? this.create(), end = reader.pos + length;
  4399.     while (reader.pos < end) {
  4400.       let [fieldNo, wireType] = reader.tag();
  4401.       switch (fieldNo) {
  4402.         case 1:
  4403.           message.allowActivityPartyPrivacyFriends = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.allowActivityPartyPrivacyFriends);
  4404.           break;
  4405.         case 2:
  4406.           message.allowActivityPartyPrivacyVoiceChannel = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.allowActivityPartyPrivacyVoiceChannel);
  4407.           break;
  4408.         case 3:
  4409.           if (wireType === WireType.LengthDelimited)
  4410.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  4411.               message.restrictedGuildIds.push(reader.fixed64().toBigInt());
  4412.           else
  4413.             message.restrictedGuildIds.push(reader.fixed64().toBigInt());
  4414.           break;
  4415.         case 4:
  4416.           message.defaultGuildsRestricted = reader.bool();
  4417.           break;
  4418.         case 7:
  4419.           message.allowAccessibilityDetection = reader.bool();
  4420.           break;
  4421.         case 8:
  4422.           message.detectPlatformAccounts = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.detectPlatformAccounts);
  4423.           break;
  4424.         case 9:
  4425.           message.passwordless = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.passwordless);
  4426.           break;
  4427.         case 10:
  4428.           message.contactSyncEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.contactSyncEnabled);
  4429.           break;
  4430.         case 11:
  4431.           message.friendSourceFlags = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.friendSourceFlags);
  4432.           break;
  4433.         case 12:
  4434.           message.friendDiscoveryFlags = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.friendDiscoveryFlags);
  4435.           break;
  4436.         case 13:
  4437.           if (wireType === WireType.LengthDelimited)
  4438.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  4439.               message.activityRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4440.           else
  4441.             message.activityRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4442.           break;
  4443.         case 14:
  4444.           message.defaultGuildsActivityRestricted = reader.int32();
  4445.           break;
  4446.         case 15:
  4447.           if (wireType === WireType.LengthDelimited)
  4448.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  4449.               message.activityJoiningRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4450.           else
  4451.             message.activityJoiningRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4452.           break;
  4453.         case 16:
  4454.           if (wireType === WireType.LengthDelimited)
  4455.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  4456.               message.messageRequestRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4457.           else
  4458.             message.messageRequestRestrictedGuildIds.push(reader.fixed64().toBigInt());
  4459.           break;
  4460.         case 17:
  4461.           message.defaultMessageRequestRestricted = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.defaultMessageRequestRestricted);
  4462.           break;
  4463.         case 18:
  4464.           message.dropsOptedOut = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.dropsOptedOut);
  4465.           break;
  4466.         case 19:
  4467.           message.nonSpamRetrainingOptIn = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.nonSpamRetrainingOptIn);
  4468.           break;
  4469.         case 20:
  4470.           message.familyCenterEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.familyCenterEnabled);
  4471.           break;
  4472.         case 21:
  4473.           message.familyCenterEnabledV2 = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.familyCenterEnabledV2);
  4474.           break;
  4475.         case 22:
  4476.           message.hideLegacyUsername = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.hideLegacyUsername);
  4477.           break;
  4478.         case 23:
  4479.           message.inappropriateConversationWarnings = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.inappropriateConversationWarnings);
  4480.           break;
  4481.         case 24:
  4482.           message.recentGamesEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.recentGamesEnabled);
  4483.           break;
  4484.         case 25:
  4485.           message.guildsLeaderboardOptOutDefault = reader.int32();
  4486.           break;
  4487.         case 26:
  4488.           message.allowGameFriendDmsInDiscord = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.allowGameFriendDmsInDiscord);
  4489.           break;
  4490.         case 27:
  4491.           message.defaultGuildsRestrictedV2 = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.defaultGuildsRestrictedV2);
  4492.           break;
  4493.         case 28:
  4494.           message.slayerSdkReceiveDmsInGame = reader.int32();
  4495.           break;
  4496.         default:
  4497.           let u = options.readUnknownField;
  4498.           if (u === "throw")
  4499.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4500.           let d = reader.skip(wireType);
  4501.           if (u !== false)
  4502.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4503.       }
  4504.     }
  4505.     return message;
  4506.   }
  4507.   internalBinaryWrite(message, writer, options) {
  4508.     if (message.allowActivityPartyPrivacyFriends)
  4509.       BoolValue.internalBinaryWrite(message.allowActivityPartyPrivacyFriends, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4510.     if (message.allowActivityPartyPrivacyVoiceChannel)
  4511.       BoolValue.internalBinaryWrite(message.allowActivityPartyPrivacyVoiceChannel, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4512.     if (message.restrictedGuildIds.length) {
  4513.       writer.tag(3, WireType.LengthDelimited).fork();
  4514.       for (let i = 0;i < message.restrictedGuildIds.length; i++)
  4515.         writer.fixed64(message.restrictedGuildIds[i]);
  4516.       writer.join();
  4517.     }
  4518.     if (message.defaultGuildsRestricted !== false)
  4519.       writer.tag(4, WireType.Varint).bool(message.defaultGuildsRestricted);
  4520.     if (message.allowAccessibilityDetection !== false)
  4521.       writer.tag(7, WireType.Varint).bool(message.allowAccessibilityDetection);
  4522.     if (message.detectPlatformAccounts)
  4523.       BoolValue.internalBinaryWrite(message.detectPlatformAccounts, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  4524.     if (message.passwordless)
  4525.       BoolValue.internalBinaryWrite(message.passwordless, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  4526.     if (message.contactSyncEnabled)
  4527.       BoolValue.internalBinaryWrite(message.contactSyncEnabled, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  4528.     if (message.friendSourceFlags)
  4529.       UInt32Value.internalBinaryWrite(message.friendSourceFlags, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  4530.     if (message.friendDiscoveryFlags)
  4531.       UInt32Value.internalBinaryWrite(message.friendDiscoveryFlags, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
  4532.     if (message.activityRestrictedGuildIds.length) {
  4533.       writer.tag(13, WireType.LengthDelimited).fork();
  4534.       for (let i = 0;i < message.activityRestrictedGuildIds.length; i++)
  4535.         writer.fixed64(message.activityRestrictedGuildIds[i]);
  4536.       writer.join();
  4537.     }
  4538.     if (message.defaultGuildsActivityRestricted !== 0)
  4539.       writer.tag(14, WireType.Varint).int32(message.defaultGuildsActivityRestricted);
  4540.     if (message.activityJoiningRestrictedGuildIds.length) {
  4541.       writer.tag(15, WireType.LengthDelimited).fork();
  4542.       for (let i = 0;i < message.activityJoiningRestrictedGuildIds.length; i++)
  4543.         writer.fixed64(message.activityJoiningRestrictedGuildIds[i]);
  4544.       writer.join();
  4545.     }
  4546.     if (message.messageRequestRestrictedGuildIds.length) {
  4547.       writer.tag(16, WireType.LengthDelimited).fork();
  4548.       for (let i = 0;i < message.messageRequestRestrictedGuildIds.length; i++)
  4549.         writer.fixed64(message.messageRequestRestrictedGuildIds[i]);
  4550.       writer.join();
  4551.     }
  4552.     if (message.defaultMessageRequestRestricted)
  4553.       BoolValue.internalBinaryWrite(message.defaultMessageRequestRestricted, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
  4554.     if (message.dropsOptedOut)
  4555.       BoolValue.internalBinaryWrite(message.dropsOptedOut, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
  4556.     if (message.nonSpamRetrainingOptIn)
  4557.       BoolValue.internalBinaryWrite(message.nonSpamRetrainingOptIn, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
  4558.     if (message.familyCenterEnabled)
  4559.       BoolValue.internalBinaryWrite(message.familyCenterEnabled, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
  4560.     if (message.familyCenterEnabledV2)
  4561.       BoolValue.internalBinaryWrite(message.familyCenterEnabledV2, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
  4562.     if (message.hideLegacyUsername)
  4563.       BoolValue.internalBinaryWrite(message.hideLegacyUsername, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
  4564.     if (message.inappropriateConversationWarnings)
  4565.       BoolValue.internalBinaryWrite(message.inappropriateConversationWarnings, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
  4566.     if (message.recentGamesEnabled)
  4567.       BoolValue.internalBinaryWrite(message.recentGamesEnabled, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
  4568.     if (message.guildsLeaderboardOptOutDefault !== 0)
  4569.       writer.tag(25, WireType.Varint).int32(message.guildsLeaderboardOptOutDefault);
  4570.     if (message.allowGameFriendDmsInDiscord)
  4571.       BoolValue.internalBinaryWrite(message.allowGameFriendDmsInDiscord, writer.tag(26, WireType.LengthDelimited).fork(), options).join();
  4572.     if (message.defaultGuildsRestrictedV2)
  4573.       BoolValue.internalBinaryWrite(message.defaultGuildsRestrictedV2, writer.tag(27, WireType.LengthDelimited).fork(), options).join();
  4574.     if (message.slayerSdkReceiveDmsInGame !== 0)
  4575.       writer.tag(28, WireType.Varint).int32(message.slayerSdkReceiveDmsInGame);
  4576.     let u = options.writeUnknownFields;
  4577.     if (u !== false)
  4578.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4579.     return writer;
  4580.   }
  4581. }
  4582. var PreloadedUserSettings_PrivacySettings = new PreloadedUserSettings_PrivacySettings$Type;
  4583.  
  4584. class PreloadedUserSettings_DebugSettings$Type extends MessageType {
  4585.   constructor() {
  4586.     super("discord_protos.discord_users.v1.PreloadedUserSettings.DebugSettings", [
  4587.       { no: 1, name: "rtc_panel_show_voice_states", kind: "message", T: () => BoolValue }
  4588.     ]);
  4589.   }
  4590.   create(value) {
  4591.     const message = globalThis.Object.create(this.messagePrototype);
  4592.     if (value !== undefined)
  4593.       reflectionMergePartial(this, message, value);
  4594.     return message;
  4595.   }
  4596.   internalBinaryRead(reader, length, options, target) {
  4597.     let message = target ?? this.create(), end = reader.pos + length;
  4598.     while (reader.pos < end) {
  4599.       let [fieldNo, wireType] = reader.tag();
  4600.       switch (fieldNo) {
  4601.         case 1:
  4602.           message.rtcPanelShowVoiceStates = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.rtcPanelShowVoiceStates);
  4603.           break;
  4604.         default:
  4605.           let u = options.readUnknownField;
  4606.           if (u === "throw")
  4607.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4608.           let d = reader.skip(wireType);
  4609.           if (u !== false)
  4610.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4611.       }
  4612.     }
  4613.     return message;
  4614.   }
  4615.   internalBinaryWrite(message, writer, options) {
  4616.     if (message.rtcPanelShowVoiceStates)
  4617.       BoolValue.internalBinaryWrite(message.rtcPanelShowVoiceStates, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4618.     let u = options.writeUnknownFields;
  4619.     if (u !== false)
  4620.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4621.     return writer;
  4622.   }
  4623. }
  4624. var PreloadedUserSettings_DebugSettings = new PreloadedUserSettings_DebugSettings$Type;
  4625.  
  4626. class PreloadedUserSettings_GameLibrarySettings$Type extends MessageType {
  4627.   constructor() {
  4628.     super("discord_protos.discord_users.v1.PreloadedUserSettings.GameLibrarySettings", [
  4629.       { no: 1, name: "install_shortcut_desktop", kind: "message", T: () => BoolValue },
  4630.       { no: 2, name: "install_shortcut_start_menu", kind: "message", T: () => BoolValue },
  4631.       { no: 3, name: "disable_games_tab", kind: "message", T: () => BoolValue }
  4632.     ]);
  4633.   }
  4634.   create(value) {
  4635.     const message = globalThis.Object.create(this.messagePrototype);
  4636.     if (value !== undefined)
  4637.       reflectionMergePartial(this, message, value);
  4638.     return message;
  4639.   }
  4640.   internalBinaryRead(reader, length, options, target) {
  4641.     let message = target ?? this.create(), end = reader.pos + length;
  4642.     while (reader.pos < end) {
  4643.       let [fieldNo, wireType] = reader.tag();
  4644.       switch (fieldNo) {
  4645.         case 1:
  4646.           message.installShortcutDesktop = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.installShortcutDesktop);
  4647.           break;
  4648.         case 2:
  4649.           message.installShortcutStartMenu = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.installShortcutStartMenu);
  4650.           break;
  4651.         case 3:
  4652.           message.disableGamesTab = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.disableGamesTab);
  4653.           break;
  4654.         default:
  4655.           let u = options.readUnknownField;
  4656.           if (u === "throw")
  4657.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4658.           let d = reader.skip(wireType);
  4659.           if (u !== false)
  4660.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4661.       }
  4662.     }
  4663.     return message;
  4664.   }
  4665.   internalBinaryWrite(message, writer, options) {
  4666.     if (message.installShortcutDesktop)
  4667.       BoolValue.internalBinaryWrite(message.installShortcutDesktop, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4668.     if (message.installShortcutStartMenu)
  4669.       BoolValue.internalBinaryWrite(message.installShortcutStartMenu, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4670.     if (message.disableGamesTab)
  4671.       BoolValue.internalBinaryWrite(message.disableGamesTab, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  4672.     let u = options.writeUnknownFields;
  4673.     if (u !== false)
  4674.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4675.     return writer;
  4676.   }
  4677. }
  4678. var PreloadedUserSettings_GameLibrarySettings = new PreloadedUserSettings_GameLibrarySettings$Type;
  4679.  
  4680. class PreloadedUserSettings_CustomStatus$Type extends MessageType {
  4681.   constructor() {
  4682.     super("discord_protos.discord_users.v1.PreloadedUserSettings.CustomStatus", [
  4683.       { no: 1, name: "text", kind: "scalar", T: 9 },
  4684.       { no: 2, name: "emoji_id", kind: "scalar", T: 6, L: 0 },
  4685.       { no: 3, name: "emoji_name", kind: "scalar", T: 9 },
  4686.       { no: 4, name: "expires_at_ms", kind: "scalar", T: 6, L: 0 },
  4687.       { no: 5, name: "created_at_ms", kind: "scalar", T: 6, L: 0 },
  4688.       { no: 6, name: "label", kind: "message", T: () => StringValue }
  4689.     ]);
  4690.   }
  4691.   create(value) {
  4692.     const message = globalThis.Object.create(this.messagePrototype);
  4693.     message.text = "";
  4694.     message.emojiId = 0n;
  4695.     message.emojiName = "";
  4696.     message.expiresAtMs = 0n;
  4697.     message.createdAtMs = 0n;
  4698.     if (value !== undefined)
  4699.       reflectionMergePartial(this, message, value);
  4700.     return message;
  4701.   }
  4702.   internalBinaryRead(reader, length, options, target) {
  4703.     let message = target ?? this.create(), end = reader.pos + length;
  4704.     while (reader.pos < end) {
  4705.       let [fieldNo, wireType] = reader.tag();
  4706.       switch (fieldNo) {
  4707.         case 1:
  4708.           message.text = reader.string();
  4709.           break;
  4710.         case 2:
  4711.           message.emojiId = reader.fixed64().toBigInt();
  4712.           break;
  4713.         case 3:
  4714.           message.emojiName = reader.string();
  4715.           break;
  4716.         case 4:
  4717.           message.expiresAtMs = reader.fixed64().toBigInt();
  4718.           break;
  4719.         case 5:
  4720.           message.createdAtMs = reader.fixed64().toBigInt();
  4721.           break;
  4722.         case 6:
  4723.           message.label = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.label);
  4724.           break;
  4725.         default:
  4726.           let u = options.readUnknownField;
  4727.           if (u === "throw")
  4728.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4729.           let d = reader.skip(wireType);
  4730.           if (u !== false)
  4731.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4732.       }
  4733.     }
  4734.     return message;
  4735.   }
  4736.   internalBinaryWrite(message, writer, options) {
  4737.     if (message.text !== "")
  4738.       writer.tag(1, WireType.LengthDelimited).string(message.text);
  4739.     if (message.emojiId !== 0n)
  4740.       writer.tag(2, WireType.Bit64).fixed64(message.emojiId);
  4741.     if (message.emojiName !== "")
  4742.       writer.tag(3, WireType.LengthDelimited).string(message.emojiName);
  4743.     if (message.expiresAtMs !== 0n)
  4744.       writer.tag(4, WireType.Bit64).fixed64(message.expiresAtMs);
  4745.     if (message.createdAtMs !== 0n)
  4746.       writer.tag(5, WireType.Bit64).fixed64(message.createdAtMs);
  4747.     if (message.label)
  4748.       StringValue.internalBinaryWrite(message.label, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  4749.     let u = options.writeUnknownFields;
  4750.     if (u !== false)
  4751.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4752.     return writer;
  4753.   }
  4754. }
  4755. var PreloadedUserSettings_CustomStatus = new PreloadedUserSettings_CustomStatus$Type;
  4756.  
  4757. class PreloadedUserSettings_StatusSettings$Type extends MessageType {
  4758.   constructor() {
  4759.     super("discord_protos.discord_users.v1.PreloadedUserSettings.StatusSettings", [
  4760.       { no: 1, name: "status", kind: "message", T: () => StringValue },
  4761.       { no: 2, name: "custom_status", kind: "message", T: () => PreloadedUserSettings_CustomStatus },
  4762.       { no: 3, name: "show_current_game", kind: "message", T: () => BoolValue },
  4763.       { no: 4, name: "status_expires_at_ms", kind: "scalar", T: 6, L: 0 }
  4764.     ]);
  4765.   }
  4766.   create(value) {
  4767.     const message = globalThis.Object.create(this.messagePrototype);
  4768.     message.statusExpiresAtMs = 0n;
  4769.     if (value !== undefined)
  4770.       reflectionMergePartial(this, message, value);
  4771.     return message;
  4772.   }
  4773.   internalBinaryRead(reader, length, options, target) {
  4774.     let message = target ?? this.create(), end = reader.pos + length;
  4775.     while (reader.pos < end) {
  4776.       let [fieldNo, wireType] = reader.tag();
  4777.       switch (fieldNo) {
  4778.         case 1:
  4779.           message.status = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.status);
  4780.           break;
  4781.         case 2:
  4782.           message.customStatus = PreloadedUserSettings_CustomStatus.internalBinaryRead(reader, reader.uint32(), options, message.customStatus);
  4783.           break;
  4784.         case 3:
  4785.           message.showCurrentGame = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.showCurrentGame);
  4786.           break;
  4787.         case 4:
  4788.           message.statusExpiresAtMs = reader.fixed64().toBigInt();
  4789.           break;
  4790.         default:
  4791.           let u = options.readUnknownField;
  4792.           if (u === "throw")
  4793.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4794.           let d = reader.skip(wireType);
  4795.           if (u !== false)
  4796.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4797.       }
  4798.     }
  4799.     return message;
  4800.   }
  4801.   internalBinaryWrite(message, writer, options) {
  4802.     if (message.status)
  4803.       StringValue.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4804.     if (message.customStatus)
  4805.       PreloadedUserSettings_CustomStatus.internalBinaryWrite(message.customStatus, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4806.     if (message.showCurrentGame)
  4807.       BoolValue.internalBinaryWrite(message.showCurrentGame, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  4808.     if (message.statusExpiresAtMs !== 0n)
  4809.       writer.tag(4, WireType.Bit64).fixed64(message.statusExpiresAtMs);
  4810.     let u = options.writeUnknownFields;
  4811.     if (u !== false)
  4812.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4813.     return writer;
  4814.   }
  4815. }
  4816. var PreloadedUserSettings_StatusSettings = new PreloadedUserSettings_StatusSettings$Type;
  4817.  
  4818. class PreloadedUserSettings_LocalizationSettings$Type extends MessageType {
  4819.   constructor() {
  4820.     super("discord_protos.discord_users.v1.PreloadedUserSettings.LocalizationSettings", [
  4821.       { no: 1, name: "locale", kind: "message", T: () => StringValue },
  4822.       { no: 2, name: "timezone_offset", kind: "message", T: () => Int32Value }
  4823.     ]);
  4824.   }
  4825.   create(value) {
  4826.     const message = globalThis.Object.create(this.messagePrototype);
  4827.     if (value !== undefined)
  4828.       reflectionMergePartial(this, message, value);
  4829.     return message;
  4830.   }
  4831.   internalBinaryRead(reader, length, options, target) {
  4832.     let message = target ?? this.create(), end = reader.pos + length;
  4833.     while (reader.pos < end) {
  4834.       let [fieldNo, wireType] = reader.tag();
  4835.       switch (fieldNo) {
  4836.         case 1:
  4837.           message.locale = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.locale);
  4838.           break;
  4839.         case 2:
  4840.           message.timezoneOffset = Int32Value.internalBinaryRead(reader, reader.uint32(), options, message.timezoneOffset);
  4841.           break;
  4842.         default:
  4843.           let u = options.readUnknownField;
  4844.           if (u === "throw")
  4845.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4846.           let d = reader.skip(wireType);
  4847.           if (u !== false)
  4848.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4849.       }
  4850.     }
  4851.     return message;
  4852.   }
  4853.   internalBinaryWrite(message, writer, options) {
  4854.     if (message.locale)
  4855.       StringValue.internalBinaryWrite(message.locale, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  4856.     if (message.timezoneOffset)
  4857.       Int32Value.internalBinaryWrite(message.timezoneOffset, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4858.     let u = options.writeUnknownFields;
  4859.     if (u !== false)
  4860.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4861.     return writer;
  4862.   }
  4863. }
  4864. var PreloadedUserSettings_LocalizationSettings = new PreloadedUserSettings_LocalizationSettings$Type;
  4865.  
  4866. class PreloadedUserSettings_ClientThemeSettings$Type extends MessageType {
  4867.   constructor() {
  4868.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ClientThemeSettings", [
  4869.       { no: 2, name: "background_gradient_preset_id", kind: "message", T: () => UInt32Value }
  4870.     ]);
  4871.   }
  4872.   create(value) {
  4873.     const message = globalThis.Object.create(this.messagePrototype);
  4874.     if (value !== undefined)
  4875.       reflectionMergePartial(this, message, value);
  4876.     return message;
  4877.   }
  4878.   internalBinaryRead(reader, length, options, target) {
  4879.     let message = target ?? this.create(), end = reader.pos + length;
  4880.     while (reader.pos < end) {
  4881.       let [fieldNo, wireType] = reader.tag();
  4882.       switch (fieldNo) {
  4883.         case 2:
  4884.           message.backgroundGradientPresetId = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.backgroundGradientPresetId);
  4885.           break;
  4886.         default:
  4887.           let u = options.readUnknownField;
  4888.           if (u === "throw")
  4889.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4890.           let d = reader.skip(wireType);
  4891.           if (u !== false)
  4892.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4893.       }
  4894.     }
  4895.     return message;
  4896.   }
  4897.   internalBinaryWrite(message, writer, options) {
  4898.     if (message.backgroundGradientPresetId)
  4899.       UInt32Value.internalBinaryWrite(message.backgroundGradientPresetId, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  4900.     let u = options.writeUnknownFields;
  4901.     if (u !== false)
  4902.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  4903.     return writer;
  4904.   }
  4905. }
  4906. var PreloadedUserSettings_ClientThemeSettings = new PreloadedUserSettings_ClientThemeSettings$Type;
  4907.  
  4908. class PreloadedUserSettings_AppearanceSettings$Type extends MessageType {
  4909.   constructor() {
  4910.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AppearanceSettings", [
  4911.       { no: 1, name: "theme", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.Theme", PreloadedUserSettings_Theme, "THEME_"] },
  4912.       { no: 2, name: "developer_mode", kind: "scalar", T: 8 },
  4913.       { no: 3, name: "client_theme_settings", kind: "message", T: () => PreloadedUserSettings_ClientThemeSettings },
  4914.       { no: 4, name: "mobile_redesign_disabled", kind: "scalar", T: 8 },
  4915.       { no: 6, name: "channel_list_layout", kind: "message", T: () => StringValue },
  4916.       { no: 7, name: "message_previews", kind: "message", T: () => StringValue },
  4917.       { no: 8, name: "search_result_exact_count_enabled", kind: "message", T: () => BoolValue },
  4918.       { no: 9, name: "timestamp_hour_cycle", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.TimestampHourCycle", PreloadedUserSettings_TimestampHourCycle, "TIMESTAMP_HOUR_CYCLE_"] },
  4919.       { no: 10, name: "happening_now_cards_disabled", kind: "message", T: () => BoolValue },
  4920.       { no: 11, name: "launch_pad_mode", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.LaunchPadMode", PreloadedUserSettings_LaunchPadMode, "LAUNCH_PAD_MODE_"] },
  4921.       { no: 12, name: "ui_density", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.UIDensity", PreloadedUserSettings_UIDensity] },
  4922.       { no: 13, name: "swipe_right_to_left_mode", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.SwipeRightToLeftMode", PreloadedUserSettings_SwipeRightToLeftMode, "SWIPE_RIGHT_TO_LEFT_MODE_"] }
  4923.     ]);
  4924.   }
  4925.   create(value) {
  4926.     const message = globalThis.Object.create(this.messagePrototype);
  4927.     message.theme = 0;
  4928.     message.developerMode = false;
  4929.     message.mobileRedesignDisabled = false;
  4930.     message.timestampHourCycle = 0;
  4931.     message.launchPadMode = 0;
  4932.     message.uiDensity = 0;
  4933.     message.swipeRightToLeftMode = 0;
  4934.     if (value !== undefined)
  4935.       reflectionMergePartial(this, message, value);
  4936.     return message;
  4937.   }
  4938.   internalBinaryRead(reader, length, options, target) {
  4939.     let message = target ?? this.create(), end = reader.pos + length;
  4940.     while (reader.pos < end) {
  4941.       let [fieldNo, wireType] = reader.tag();
  4942.       switch (fieldNo) {
  4943.         case 1:
  4944.           message.theme = reader.int32();
  4945.           break;
  4946.         case 2:
  4947.           message.developerMode = reader.bool();
  4948.           break;
  4949.         case 3:
  4950.           message.clientThemeSettings = PreloadedUserSettings_ClientThemeSettings.internalBinaryRead(reader, reader.uint32(), options, message.clientThemeSettings);
  4951.           break;
  4952.         case 4:
  4953.           message.mobileRedesignDisabled = reader.bool();
  4954.           break;
  4955.         case 6:
  4956.           message.channelListLayout = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.channelListLayout);
  4957.           break;
  4958.         case 7:
  4959.           message.messagePreviews = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.messagePreviews);
  4960.           break;
  4961.         case 8:
  4962.           message.searchResultExactCountEnabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.searchResultExactCountEnabled);
  4963.           break;
  4964.         case 9:
  4965.           message.timestampHourCycle = reader.int32();
  4966.           break;
  4967.         case 10:
  4968.           message.happeningNowCardsDisabled = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.happeningNowCardsDisabled);
  4969.           break;
  4970.         case 11:
  4971.           message.launchPadMode = reader.int32();
  4972.           break;
  4973.         case 12:
  4974.           message.uiDensity = reader.int32();
  4975.           break;
  4976.         case 13:
  4977.           message.swipeRightToLeftMode = reader.int32();
  4978.           break;
  4979.         default:
  4980.           let u = options.readUnknownField;
  4981.           if (u === "throw")
  4982.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  4983.           let d = reader.skip(wireType);
  4984.           if (u !== false)
  4985.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  4986.       }
  4987.     }
  4988.     return message;
  4989.   }
  4990.   internalBinaryWrite(message, writer, options) {
  4991.     if (message.theme !== 0)
  4992.       writer.tag(1, WireType.Varint).int32(message.theme);
  4993.     if (message.developerMode !== false)
  4994.       writer.tag(2, WireType.Varint).bool(message.developerMode);
  4995.     if (message.clientThemeSettings)
  4996.       PreloadedUserSettings_ClientThemeSettings.internalBinaryWrite(message.clientThemeSettings, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  4997.     if (message.mobileRedesignDisabled !== false)
  4998.       writer.tag(4, WireType.Varint).bool(message.mobileRedesignDisabled);
  4999.     if (message.channelListLayout)
  5000.       StringValue.internalBinaryWrite(message.channelListLayout, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  5001.     if (message.messagePreviews)
  5002.       StringValue.internalBinaryWrite(message.messagePreviews, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  5003.     if (message.searchResultExactCountEnabled)
  5004.       BoolValue.internalBinaryWrite(message.searchResultExactCountEnabled, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  5005.     if (message.timestampHourCycle !== 0)
  5006.       writer.tag(9, WireType.Varint).int32(message.timestampHourCycle);
  5007.     if (message.happeningNowCardsDisabled)
  5008.       BoolValue.internalBinaryWrite(message.happeningNowCardsDisabled, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  5009.     if (message.launchPadMode !== 0)
  5010.       writer.tag(11, WireType.Varint).int32(message.launchPadMode);
  5011.     if (message.uiDensity !== 0)
  5012.       writer.tag(12, WireType.Varint).int32(message.uiDensity);
  5013.     if (message.swipeRightToLeftMode !== 0)
  5014.       writer.tag(13, WireType.Varint).int32(message.swipeRightToLeftMode);
  5015.     let u = options.writeUnknownFields;
  5016.     if (u !== false)
  5017.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5018.     return writer;
  5019.   }
  5020. }
  5021. var PreloadedUserSettings_AppearanceSettings = new PreloadedUserSettings_AppearanceSettings$Type;
  5022.  
  5023. class PreloadedUserSettings_GuildFolder$Type extends MessageType {
  5024.   constructor() {
  5025.     super("discord_protos.discord_users.v1.PreloadedUserSettings.GuildFolder", [
  5026.       { no: 1, name: "guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  5027.       { no: 2, name: "id", kind: "message", T: () => Int64Value },
  5028.       { no: 3, name: "name", kind: "message", T: () => StringValue },
  5029.       { no: 4, name: "color", kind: "message", T: () => UInt64Value }
  5030.     ]);
  5031.   }
  5032.   create(value) {
  5033.     const message = globalThis.Object.create(this.messagePrototype);
  5034.     message.guildIds = [];
  5035.     if (value !== undefined)
  5036.       reflectionMergePartial(this, message, value);
  5037.     return message;
  5038.   }
  5039.   internalBinaryRead(reader, length, options, target) {
  5040.     let message = target ?? this.create(), end = reader.pos + length;
  5041.     while (reader.pos < end) {
  5042.       let [fieldNo, wireType] = reader.tag();
  5043.       switch (fieldNo) {
  5044.         case 1:
  5045.           if (wireType === WireType.LengthDelimited)
  5046.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  5047.               message.guildIds.push(reader.fixed64().toBigInt());
  5048.           else
  5049.             message.guildIds.push(reader.fixed64().toBigInt());
  5050.           break;
  5051.         case 2:
  5052.           message.id = Int64Value.internalBinaryRead(reader, reader.uint32(), options, message.id);
  5053.           break;
  5054.         case 3:
  5055.           message.name = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.name);
  5056.           break;
  5057.         case 4:
  5058.           message.color = UInt64Value.internalBinaryRead(reader, reader.uint32(), options, message.color);
  5059.           break;
  5060.         default:
  5061.           let u = options.readUnknownField;
  5062.           if (u === "throw")
  5063.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5064.           let d = reader.skip(wireType);
  5065.           if (u !== false)
  5066.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5067.       }
  5068.     }
  5069.     return message;
  5070.   }
  5071.   internalBinaryWrite(message, writer, options) {
  5072.     if (message.guildIds.length) {
  5073.       writer.tag(1, WireType.LengthDelimited).fork();
  5074.       for (let i = 0;i < message.guildIds.length; i++)
  5075.         writer.fixed64(message.guildIds[i]);
  5076.       writer.join();
  5077.     }
  5078.     if (message.id)
  5079.       Int64Value.internalBinaryWrite(message.id, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  5080.     if (message.name)
  5081.       StringValue.internalBinaryWrite(message.name, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  5082.     if (message.color)
  5083.       UInt64Value.internalBinaryWrite(message.color, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  5084.     let u = options.writeUnknownFields;
  5085.     if (u !== false)
  5086.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5087.     return writer;
  5088.   }
  5089. }
  5090. var PreloadedUserSettings_GuildFolder = new PreloadedUserSettings_GuildFolder$Type;
  5091.  
  5092. class PreloadedUserSettings_GuildFolders$Type extends MessageType {
  5093.   constructor() {
  5094.     super("discord_protos.discord_users.v1.PreloadedUserSettings.GuildFolders", [
  5095.       { no: 1, name: "folders", kind: "message", repeat: 1, T: () => PreloadedUserSettings_GuildFolder },
  5096.       { no: 2, name: "guild_positions", kind: "scalar", repeat: 1, T: 6, L: 0 }
  5097.     ]);
  5098.   }
  5099.   create(value) {
  5100.     const message = globalThis.Object.create(this.messagePrototype);
  5101.     message.folders = [];
  5102.     message.guildPositions = [];
  5103.     if (value !== undefined)
  5104.       reflectionMergePartial(this, message, value);
  5105.     return message;
  5106.   }
  5107.   internalBinaryRead(reader, length, options, target) {
  5108.     let message = target ?? this.create(), end = reader.pos + length;
  5109.     while (reader.pos < end) {
  5110.       let [fieldNo, wireType] = reader.tag();
  5111.       switch (fieldNo) {
  5112.         case 1:
  5113.           message.folders.push(PreloadedUserSettings_GuildFolder.internalBinaryRead(reader, reader.uint32(), options));
  5114.           break;
  5115.         case 2:
  5116.           if (wireType === WireType.LengthDelimited)
  5117.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  5118.               message.guildPositions.push(reader.fixed64().toBigInt());
  5119.           else
  5120.             message.guildPositions.push(reader.fixed64().toBigInt());
  5121.           break;
  5122.         default:
  5123.           let u = options.readUnknownField;
  5124.           if (u === "throw")
  5125.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5126.           let d = reader.skip(wireType);
  5127.           if (u !== false)
  5128.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5129.       }
  5130.     }
  5131.     return message;
  5132.   }
  5133.   internalBinaryWrite(message, writer, options) {
  5134.     for (let i = 0;i < message.folders.length; i++)
  5135.       PreloadedUserSettings_GuildFolder.internalBinaryWrite(message.folders[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  5136.     if (message.guildPositions.length) {
  5137.       writer.tag(2, WireType.LengthDelimited).fork();
  5138.       for (let i = 0;i < message.guildPositions.length; i++)
  5139.         writer.fixed64(message.guildPositions[i]);
  5140.       writer.join();
  5141.     }
  5142.     let u = options.writeUnknownFields;
  5143.     if (u !== false)
  5144.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5145.     return writer;
  5146.   }
  5147. }
  5148. var PreloadedUserSettings_GuildFolders = new PreloadedUserSettings_GuildFolders$Type;
  5149.  
  5150. class PreloadedUserSettings_FavoriteChannel$Type extends MessageType {
  5151.   constructor() {
  5152.     super("discord_protos.discord_users.v1.PreloadedUserSettings.FavoriteChannel", [
  5153.       { no: 1, name: "nickname", kind: "scalar", T: 9 },
  5154.       { no: 2, name: "type", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.FavoriteChannelType", PreloadedUserSettings_FavoriteChannelType, "FAVORITE_CHANNEL_TYPE_"] },
  5155.       { no: 3, name: "position", kind: "scalar", T: 13 },
  5156.       { no: 4, name: "parent_id", kind: "scalar", T: 6, L: 0 }
  5157.     ]);
  5158.   }
  5159.   create(value) {
  5160.     const message = globalThis.Object.create(this.messagePrototype);
  5161.     message.nickname = "";
  5162.     message.type = 0;
  5163.     message.position = 0;
  5164.     message.parentId = 0n;
  5165.     if (value !== undefined)
  5166.       reflectionMergePartial(this, message, value);
  5167.     return message;
  5168.   }
  5169.   internalBinaryRead(reader, length, options, target) {
  5170.     let message = target ?? this.create(), end = reader.pos + length;
  5171.     while (reader.pos < end) {
  5172.       let [fieldNo, wireType] = reader.tag();
  5173.       switch (fieldNo) {
  5174.         case 1:
  5175.           message.nickname = reader.string();
  5176.           break;
  5177.         case 2:
  5178.           message.type = reader.int32();
  5179.           break;
  5180.         case 3:
  5181.           message.position = reader.uint32();
  5182.           break;
  5183.         case 4:
  5184.           message.parentId = reader.fixed64().toBigInt();
  5185.           break;
  5186.         default:
  5187.           let u = options.readUnknownField;
  5188.           if (u === "throw")
  5189.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5190.           let d = reader.skip(wireType);
  5191.           if (u !== false)
  5192.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5193.       }
  5194.     }
  5195.     return message;
  5196.   }
  5197.   internalBinaryWrite(message, writer, options) {
  5198.     if (message.nickname !== "")
  5199.       writer.tag(1, WireType.LengthDelimited).string(message.nickname);
  5200.     if (message.type !== 0)
  5201.       writer.tag(2, WireType.Varint).int32(message.type);
  5202.     if (message.position !== 0)
  5203.       writer.tag(3, WireType.Varint).uint32(message.position);
  5204.     if (message.parentId !== 0n)
  5205.       writer.tag(4, WireType.Bit64).fixed64(message.parentId);
  5206.     let u = options.writeUnknownFields;
  5207.     if (u !== false)
  5208.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5209.     return writer;
  5210.   }
  5211. }
  5212. var PreloadedUserSettings_FavoriteChannel = new PreloadedUserSettings_FavoriteChannel$Type;
  5213.  
  5214. class PreloadedUserSettings_Favorites$Type extends MessageType {
  5215.   constructor() {
  5216.     super("discord_protos.discord_users.v1.PreloadedUserSettings.Favorites", [
  5217.       { no: 1, name: "favorite_channels", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_FavoriteChannel } },
  5218.       { no: 2, name: "muted", kind: "scalar", T: 8 }
  5219.     ]);
  5220.   }
  5221.   create(value) {
  5222.     const message = globalThis.Object.create(this.messagePrototype);
  5223.     message.favoriteChannels = {};
  5224.     message.muted = false;
  5225.     if (value !== undefined)
  5226.       reflectionMergePartial(this, message, value);
  5227.     return message;
  5228.   }
  5229.   internalBinaryRead(reader, length, options, target) {
  5230.     let message = target ?? this.create(), end = reader.pos + length;
  5231.     while (reader.pos < end) {
  5232.       let [fieldNo, wireType] = reader.tag();
  5233.       switch (fieldNo) {
  5234.         case 1:
  5235.           this.binaryReadMap1(message.favoriteChannels, reader, options);
  5236.           break;
  5237.         case 2:
  5238.           message.muted = reader.bool();
  5239.           break;
  5240.         default:
  5241.           let u = options.readUnknownField;
  5242.           if (u === "throw")
  5243.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5244.           let d = reader.skip(wireType);
  5245.           if (u !== false)
  5246.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5247.       }
  5248.     }
  5249.     return message;
  5250.   }
  5251.   binaryReadMap1(map, reader, options) {
  5252.     let len = reader.uint32(), end = reader.pos + len, key, val;
  5253.     while (reader.pos < end) {
  5254.       let [fieldNo, wireType] = reader.tag();
  5255.       switch (fieldNo) {
  5256.         case 1:
  5257.           key = reader.fixed64().toString();
  5258.           break;
  5259.         case 2:
  5260.           val = PreloadedUserSettings_FavoriteChannel.internalBinaryRead(reader, reader.uint32(), options);
  5261.           break;
  5262.         default:
  5263.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.Favorites.favorite_channels");
  5264.       }
  5265.     }
  5266.     map[key ?? "0"] = val ?? PreloadedUserSettings_FavoriteChannel.create();
  5267.   }
  5268.   internalBinaryWrite(message, writer, options) {
  5269.     for (let k of globalThis.Object.keys(message.favoriteChannels)) {
  5270.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  5271.       writer.tag(2, WireType.LengthDelimited).fork();
  5272.       PreloadedUserSettings_FavoriteChannel.internalBinaryWrite(message.favoriteChannels[k], writer, options);
  5273.       writer.join().join();
  5274.     }
  5275.     if (message.muted !== false)
  5276.       writer.tag(2, WireType.Varint).bool(message.muted);
  5277.     let u = options.writeUnknownFields;
  5278.     if (u !== false)
  5279.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5280.     return writer;
  5281.   }
  5282. }
  5283. var PreloadedUserSettings_Favorites = new PreloadedUserSettings_Favorites$Type;
  5284.  
  5285. class PreloadedUserSettings_AudioContextSetting$Type extends MessageType {
  5286.   constructor() {
  5287.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AudioContextSetting", [
  5288.       { no: 1, name: "muted", kind: "scalar", T: 8 },
  5289.       { no: 2, name: "volume", kind: "scalar", T: 2 },
  5290.       { no: 3, name: "modified_at", kind: "scalar", T: 6, L: 0 },
  5291.       { no: 4, name: "soundboard_muted", kind: "scalar", T: 8 }
  5292.     ]);
  5293.   }
  5294.   create(value) {
  5295.     const message = globalThis.Object.create(this.messagePrototype);
  5296.     message.muted = false;
  5297.     message.volume = 0;
  5298.     message.modifiedAt = 0n;
  5299.     message.soundboardMuted = false;
  5300.     if (value !== undefined)
  5301.       reflectionMergePartial(this, message, value);
  5302.     return message;
  5303.   }
  5304.   internalBinaryRead(reader, length, options, target) {
  5305.     let message = target ?? this.create(), end = reader.pos + length;
  5306.     while (reader.pos < end) {
  5307.       let [fieldNo, wireType] = reader.tag();
  5308.       switch (fieldNo) {
  5309.         case 1:
  5310.           message.muted = reader.bool();
  5311.           break;
  5312.         case 2:
  5313.           message.volume = reader.float();
  5314.           break;
  5315.         case 3:
  5316.           message.modifiedAt = reader.fixed64().toBigInt();
  5317.           break;
  5318.         case 4:
  5319.           message.soundboardMuted = reader.bool();
  5320.           break;
  5321.         default:
  5322.           let u = options.readUnknownField;
  5323.           if (u === "throw")
  5324.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5325.           let d = reader.skip(wireType);
  5326.           if (u !== false)
  5327.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5328.       }
  5329.     }
  5330.     return message;
  5331.   }
  5332.   internalBinaryWrite(message, writer, options) {
  5333.     if (message.muted !== false)
  5334.       writer.tag(1, WireType.Varint).bool(message.muted);
  5335.     if (message.volume !== 0)
  5336.       writer.tag(2, WireType.Bit32).float(message.volume);
  5337.     if (message.modifiedAt !== 0n)
  5338.       writer.tag(3, WireType.Bit64).fixed64(message.modifiedAt);
  5339.     if (message.soundboardMuted !== false)
  5340.       writer.tag(4, WireType.Varint).bool(message.soundboardMuted);
  5341.     let u = options.writeUnknownFields;
  5342.     if (u !== false)
  5343.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5344.     return writer;
  5345.   }
  5346. }
  5347. var PreloadedUserSettings_AudioContextSetting = new PreloadedUserSettings_AudioContextSetting$Type;
  5348.  
  5349. class PreloadedUserSettings_AudioSettings$Type extends MessageType {
  5350.   constructor() {
  5351.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AudioSettings", [
  5352.       { no: 1, name: "user", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_AudioContextSetting } },
  5353.       { no: 2, name: "stream", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_AudioContextSetting } }
  5354.     ]);
  5355.   }
  5356.   create(value) {
  5357.     const message = globalThis.Object.create(this.messagePrototype);
  5358.     message.user = {};
  5359.     message.stream = {};
  5360.     if (value !== undefined)
  5361.       reflectionMergePartial(this, message, value);
  5362.     return message;
  5363.   }
  5364.   internalBinaryRead(reader, length, options, target) {
  5365.     let message = target ?? this.create(), end = reader.pos + length;
  5366.     while (reader.pos < end) {
  5367.       let [fieldNo, wireType] = reader.tag();
  5368.       switch (fieldNo) {
  5369.         case 1:
  5370.           this.binaryReadMap1(message.user, reader, options);
  5371.           break;
  5372.         case 2:
  5373.           this.binaryReadMap2(message.stream, reader, options);
  5374.           break;
  5375.         default:
  5376.           let u = options.readUnknownField;
  5377.           if (u === "throw")
  5378.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5379.           let d = reader.skip(wireType);
  5380.           if (u !== false)
  5381.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5382.       }
  5383.     }
  5384.     return message;
  5385.   }
  5386.   binaryReadMap1(map, reader, options) {
  5387.     let len = reader.uint32(), end = reader.pos + len, key, val;
  5388.     while (reader.pos < end) {
  5389.       let [fieldNo, wireType] = reader.tag();
  5390.       switch (fieldNo) {
  5391.         case 1:
  5392.           key = reader.fixed64().toString();
  5393.           break;
  5394.         case 2:
  5395.           val = PreloadedUserSettings_AudioContextSetting.internalBinaryRead(reader, reader.uint32(), options);
  5396.           break;
  5397.         default:
  5398.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.AudioSettings.user");
  5399.       }
  5400.     }
  5401.     map[key ?? "0"] = val ?? PreloadedUserSettings_AudioContextSetting.create();
  5402.   }
  5403.   binaryReadMap2(map, reader, options) {
  5404.     let len = reader.uint32(), end = reader.pos + len, key, val;
  5405.     while (reader.pos < end) {
  5406.       let [fieldNo, wireType] = reader.tag();
  5407.       switch (fieldNo) {
  5408.         case 1:
  5409.           key = reader.fixed64().toString();
  5410.           break;
  5411.         case 2:
  5412.           val = PreloadedUserSettings_AudioContextSetting.internalBinaryRead(reader, reader.uint32(), options);
  5413.           break;
  5414.         default:
  5415.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.AudioSettings.stream");
  5416.       }
  5417.     }
  5418.     map[key ?? "0"] = val ?? PreloadedUserSettings_AudioContextSetting.create();
  5419.   }
  5420.   internalBinaryWrite(message, writer, options) {
  5421.     for (let k of globalThis.Object.keys(message.user)) {
  5422.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  5423.       writer.tag(2, WireType.LengthDelimited).fork();
  5424.       PreloadedUserSettings_AudioContextSetting.internalBinaryWrite(message.user[k], writer, options);
  5425.       writer.join().join();
  5426.     }
  5427.     for (let k of globalThis.Object.keys(message.stream)) {
  5428.       writer.tag(2, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  5429.       writer.tag(2, WireType.LengthDelimited).fork();
  5430.       PreloadedUserSettings_AudioContextSetting.internalBinaryWrite(message.stream[k], writer, options);
  5431.       writer.join().join();
  5432.     }
  5433.     let u = options.writeUnknownFields;
  5434.     if (u !== false)
  5435.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5436.     return writer;
  5437.   }
  5438. }
  5439. var PreloadedUserSettings_AudioSettings = new PreloadedUserSettings_AudioSettings$Type;
  5440.  
  5441. class PreloadedUserSettings_CommunitiesSettings$Type extends MessageType {
  5442.   constructor() {
  5443.     super("discord_protos.discord_users.v1.PreloadedUserSettings.CommunitiesSettings", [
  5444.       { no: 1, name: "disable_home_auto_nav", kind: "message", T: () => BoolValue }
  5445.     ]);
  5446.   }
  5447.   create(value) {
  5448.     const message = globalThis.Object.create(this.messagePrototype);
  5449.     if (value !== undefined)
  5450.       reflectionMergePartial(this, message, value);
  5451.     return message;
  5452.   }
  5453.   internalBinaryRead(reader, length, options, target) {
  5454.     let message = target ?? this.create(), end = reader.pos + length;
  5455.     while (reader.pos < end) {
  5456.       let [fieldNo, wireType] = reader.tag();
  5457.       switch (fieldNo) {
  5458.         case 1:
  5459.           message.disableHomeAutoNav = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.disableHomeAutoNav);
  5460.           break;
  5461.         default:
  5462.           let u = options.readUnknownField;
  5463.           if (u === "throw")
  5464.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5465.           let d = reader.skip(wireType);
  5466.           if (u !== false)
  5467.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5468.       }
  5469.     }
  5470.     return message;
  5471.   }
  5472.   internalBinaryWrite(message, writer, options) {
  5473.     if (message.disableHomeAutoNav)
  5474.       BoolValue.internalBinaryWrite(message.disableHomeAutoNav, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  5475.     let u = options.writeUnknownFields;
  5476.     if (u !== false)
  5477.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5478.     return writer;
  5479.   }
  5480. }
  5481. var PreloadedUserSettings_CommunitiesSettings = new PreloadedUserSettings_CommunitiesSettings$Type;
  5482.  
  5483. class PreloadedUserSettings_BroadcastSettings$Type extends MessageType {
  5484.   constructor() {
  5485.     super("discord_protos.discord_users.v1.PreloadedUserSettings.BroadcastSettings", [
  5486.       { no: 1, name: "allow_friends", kind: "message", T: () => BoolValue },
  5487.       { no: 2, name: "allowed_guild_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  5488.       { no: 3, name: "allowed_user_ids", kind: "scalar", repeat: 1, T: 6, L: 0 },
  5489.       { no: 4, name: "auto_broadcast", kind: "message", T: () => BoolValue }
  5490.     ]);
  5491.   }
  5492.   create(value) {
  5493.     const message = globalThis.Object.create(this.messagePrototype);
  5494.     message.allowedGuildIds = [];
  5495.     message.allowedUserIds = [];
  5496.     if (value !== undefined)
  5497.       reflectionMergePartial(this, message, value);
  5498.     return message;
  5499.   }
  5500.   internalBinaryRead(reader, length, options, target) {
  5501.     let message = target ?? this.create(), end = reader.pos + length;
  5502.     while (reader.pos < end) {
  5503.       let [fieldNo, wireType] = reader.tag();
  5504.       switch (fieldNo) {
  5505.         case 1:
  5506.           message.allowFriends = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.allowFriends);
  5507.           break;
  5508.         case 2:
  5509.           if (wireType === WireType.LengthDelimited)
  5510.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  5511.               message.allowedGuildIds.push(reader.fixed64().toBigInt());
  5512.           else
  5513.             message.allowedGuildIds.push(reader.fixed64().toBigInt());
  5514.           break;
  5515.         case 3:
  5516.           if (wireType === WireType.LengthDelimited)
  5517.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  5518.               message.allowedUserIds.push(reader.fixed64().toBigInt());
  5519.           else
  5520.             message.allowedUserIds.push(reader.fixed64().toBigInt());
  5521.           break;
  5522.         case 4:
  5523.           message.autoBroadcast = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.autoBroadcast);
  5524.           break;
  5525.         default:
  5526.           let u = options.readUnknownField;
  5527.           if (u === "throw")
  5528.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5529.           let d = reader.skip(wireType);
  5530.           if (u !== false)
  5531.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5532.       }
  5533.     }
  5534.     return message;
  5535.   }
  5536.   internalBinaryWrite(message, writer, options) {
  5537.     if (message.allowFriends)
  5538.       BoolValue.internalBinaryWrite(message.allowFriends, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  5539.     if (message.allowedGuildIds.length) {
  5540.       writer.tag(2, WireType.LengthDelimited).fork();
  5541.       for (let i = 0;i < message.allowedGuildIds.length; i++)
  5542.         writer.fixed64(message.allowedGuildIds[i]);
  5543.       writer.join();
  5544.     }
  5545.     if (message.allowedUserIds.length) {
  5546.       writer.tag(3, WireType.LengthDelimited).fork();
  5547.       for (let i = 0;i < message.allowedUserIds.length; i++)
  5548.         writer.fixed64(message.allowedUserIds[i]);
  5549.       writer.join();
  5550.     }
  5551.     if (message.autoBroadcast)
  5552.       BoolValue.internalBinaryWrite(message.autoBroadcast, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  5553.     let u = options.writeUnknownFields;
  5554.     if (u !== false)
  5555.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5556.     return writer;
  5557.   }
  5558. }
  5559. var PreloadedUserSettings_BroadcastSettings = new PreloadedUserSettings_BroadcastSettings$Type;
  5560.  
  5561. class PreloadedUserSettings_ClipsSettings$Type extends MessageType {
  5562.   constructor() {
  5563.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ClipsSettings", [
  5564.       { no: 1, name: "allow_voice_recording", kind: "message", T: () => BoolValue }
  5565.     ]);
  5566.   }
  5567.   create(value) {
  5568.     const message = globalThis.Object.create(this.messagePrototype);
  5569.     if (value !== undefined)
  5570.       reflectionMergePartial(this, message, value);
  5571.     return message;
  5572.   }
  5573.   internalBinaryRead(reader, length, options, target) {
  5574.     let message = target ?? this.create(), end = reader.pos + length;
  5575.     while (reader.pos < end) {
  5576.       let [fieldNo, wireType] = reader.tag();
  5577.       switch (fieldNo) {
  5578.         case 1:
  5579.           message.allowVoiceRecording = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.allowVoiceRecording);
  5580.           break;
  5581.         default:
  5582.           let u = options.readUnknownField;
  5583.           if (u === "throw")
  5584.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5585.           let d = reader.skip(wireType);
  5586.           if (u !== false)
  5587.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5588.       }
  5589.     }
  5590.     return message;
  5591.   }
  5592.   internalBinaryWrite(message, writer, options) {
  5593.     if (message.allowVoiceRecording)
  5594.       BoolValue.internalBinaryWrite(message.allowVoiceRecording, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  5595.     let u = options.writeUnknownFields;
  5596.     if (u !== false)
  5597.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5598.     return writer;
  5599.   }
  5600. }
  5601. var PreloadedUserSettings_ClipsSettings = new PreloadedUserSettings_ClipsSettings$Type;
  5602.  
  5603. class PreloadedUserSettings_ForLaterSettings$Type extends MessageType {
  5604.   constructor() {
  5605.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ForLaterSettings", [
  5606.       { no: 1, name: "current_tab", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.ForLaterTab", PreloadedUserSettings_ForLaterTab, "FOR_LATER_TAB_"] }
  5607.     ]);
  5608.   }
  5609.   create(value) {
  5610.     const message = globalThis.Object.create(this.messagePrototype);
  5611.     message.currentTab = 0;
  5612.     if (value !== undefined)
  5613.       reflectionMergePartial(this, message, value);
  5614.     return message;
  5615.   }
  5616.   internalBinaryRead(reader, length, options, target) {
  5617.     let message = target ?? this.create(), end = reader.pos + length;
  5618.     while (reader.pos < end) {
  5619.       let [fieldNo, wireType] = reader.tag();
  5620.       switch (fieldNo) {
  5621.         case 1:
  5622.           message.currentTab = reader.int32();
  5623.           break;
  5624.         default:
  5625.           let u = options.readUnknownField;
  5626.           if (u === "throw")
  5627.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5628.           let d = reader.skip(wireType);
  5629.           if (u !== false)
  5630.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5631.       }
  5632.     }
  5633.     return message;
  5634.   }
  5635.   internalBinaryWrite(message, writer, options) {
  5636.     if (message.currentTab !== 0)
  5637.       writer.tag(1, WireType.Varint).int32(message.currentTab);
  5638.     let u = options.writeUnknownFields;
  5639.     if (u !== false)
  5640.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5641.     return writer;
  5642.   }
  5643. }
  5644. var PreloadedUserSettings_ForLaterSettings = new PreloadedUserSettings_ForLaterSettings$Type;
  5645.  
  5646. class PreloadedUserSettings_SafetySettings$Type extends MessageType {
  5647.   constructor() {
  5648.     super("discord_protos.discord_users.v1.PreloadedUserSettings.SafetySettings", [
  5649.       { no: 1, name: "safety_settings_preset", kind: "enum", T: () => ["discord_protos.discord_users.v1.PreloadedUserSettings.SafetySettingsPresetType", PreloadedUserSettings_SafetySettingsPresetType, "SAFETY_SETTINGS_PRESET_TYPE_"] },
  5650.       { no: 2, name: "ignore_profile_speedbump_disabled", kind: "scalar", T: 8 }
  5651.     ]);
  5652.   }
  5653.   create(value) {
  5654.     const message = globalThis.Object.create(this.messagePrototype);
  5655.     message.safetySettingsPreset = 0;
  5656.     message.ignoreProfileSpeedbumpDisabled = false;
  5657.     if (value !== undefined)
  5658.       reflectionMergePartial(this, message, value);
  5659.     return message;
  5660.   }
  5661.   internalBinaryRead(reader, length, options, target) {
  5662.     let message = target ?? this.create(), end = reader.pos + length;
  5663.     while (reader.pos < end) {
  5664.       let [fieldNo, wireType] = reader.tag();
  5665.       switch (fieldNo) {
  5666.         case 1:
  5667.           message.safetySettingsPreset = reader.int32();
  5668.           break;
  5669.         case 2:
  5670.           message.ignoreProfileSpeedbumpDisabled = reader.bool();
  5671.           break;
  5672.         default:
  5673.           let u = options.readUnknownField;
  5674.           if (u === "throw")
  5675.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5676.           let d = reader.skip(wireType);
  5677.           if (u !== false)
  5678.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5679.       }
  5680.     }
  5681.     return message;
  5682.   }
  5683.   internalBinaryWrite(message, writer, options) {
  5684.     if (message.safetySettingsPreset !== 0)
  5685.       writer.tag(1, WireType.Varint).int32(message.safetySettingsPreset);
  5686.     if (message.ignoreProfileSpeedbumpDisabled !== false)
  5687.       writer.tag(2, WireType.Varint).bool(message.ignoreProfileSpeedbumpDisabled);
  5688.     let u = options.writeUnknownFields;
  5689.     if (u !== false)
  5690.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5691.     return writer;
  5692.   }
  5693. }
  5694. var PreloadedUserSettings_SafetySettings = new PreloadedUserSettings_SafetySettings$Type;
  5695.  
  5696. class PreloadedUserSettings_ICYMISettings$Type extends MessageType {
  5697.   constructor() {
  5698.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ICYMISettings", [
  5699.       { no: 1, name: "feed_generated_at", kind: "scalar", T: 6, L: 0 }
  5700.     ]);
  5701.   }
  5702.   create(value) {
  5703.     const message = globalThis.Object.create(this.messagePrototype);
  5704.     message.feedGeneratedAt = 0n;
  5705.     if (value !== undefined)
  5706.       reflectionMergePartial(this, message, value);
  5707.     return message;
  5708.   }
  5709.   internalBinaryRead(reader, length, options, target) {
  5710.     let message = target ?? this.create(), end = reader.pos + length;
  5711.     while (reader.pos < end) {
  5712.       let [fieldNo, wireType] = reader.tag();
  5713.       switch (fieldNo) {
  5714.         case 1:
  5715.           message.feedGeneratedAt = reader.fixed64().toBigInt();
  5716.           break;
  5717.         default:
  5718.           let u = options.readUnknownField;
  5719.           if (u === "throw")
  5720.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5721.           let d = reader.skip(wireType);
  5722.           if (u !== false)
  5723.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5724.       }
  5725.     }
  5726.     return message;
  5727.   }
  5728.   internalBinaryWrite(message, writer, options) {
  5729.     if (message.feedGeneratedAt !== 0n)
  5730.       writer.tag(1, WireType.Bit64).fixed64(message.feedGeneratedAt);
  5731.     let u = options.writeUnknownFields;
  5732.     if (u !== false)
  5733.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5734.     return writer;
  5735.   }
  5736. }
  5737. var PreloadedUserSettings_ICYMISettings = new PreloadedUserSettings_ICYMISettings$Type;
  5738.  
  5739. class PreloadedUserSettings_ApplicationDMSettings$Type extends MessageType {
  5740.   constructor() {
  5741.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ApplicationDMSettings", [
  5742.       { no: 1, name: "dm_disabled", kind: "scalar", T: 8 }
  5743.     ]);
  5744.   }
  5745.   create(value) {
  5746.     const message = globalThis.Object.create(this.messagePrototype);
  5747.     message.dmDisabled = false;
  5748.     if (value !== undefined)
  5749.       reflectionMergePartial(this, message, value);
  5750.     return message;
  5751.   }
  5752.   internalBinaryRead(reader, length, options, target) {
  5753.     let message = target ?? this.create(), end = reader.pos + length;
  5754.     while (reader.pos < end) {
  5755.       let [fieldNo, wireType] = reader.tag();
  5756.       switch (fieldNo) {
  5757.         case 1:
  5758.           message.dmDisabled = reader.bool();
  5759.           break;
  5760.         default:
  5761.           let u = options.readUnknownField;
  5762.           if (u === "throw")
  5763.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5764.           let d = reader.skip(wireType);
  5765.           if (u !== false)
  5766.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5767.       }
  5768.     }
  5769.     return message;
  5770.   }
  5771.   internalBinaryWrite(message, writer, options) {
  5772.     if (message.dmDisabled !== false)
  5773.       writer.tag(1, WireType.Varint).bool(message.dmDisabled);
  5774.     let u = options.writeUnknownFields;
  5775.     if (u !== false)
  5776.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5777.     return writer;
  5778.   }
  5779. }
  5780. var PreloadedUserSettings_ApplicationDMSettings = new PreloadedUserSettings_ApplicationDMSettings$Type;
  5781.  
  5782. class PreloadedUserSettings_ApplicationSettings$Type extends MessageType {
  5783.   constructor() {
  5784.     super("discord_protos.discord_users.v1.PreloadedUserSettings.ApplicationSettings", [
  5785.       { no: 1, name: "app_dm_settings", kind: "message", T: () => PreloadedUserSettings_ApplicationDMSettings }
  5786.     ]);
  5787.   }
  5788.   create(value) {
  5789.     const message = globalThis.Object.create(this.messagePrototype);
  5790.     if (value !== undefined)
  5791.       reflectionMergePartial(this, message, value);
  5792.     return message;
  5793.   }
  5794.   internalBinaryRead(reader, length, options, target) {
  5795.     let message = target ?? this.create(), end = reader.pos + length;
  5796.     while (reader.pos < end) {
  5797.       let [fieldNo, wireType] = reader.tag();
  5798.       switch (fieldNo) {
  5799.         case 1:
  5800.           message.appDmSettings = PreloadedUserSettings_ApplicationDMSettings.internalBinaryRead(reader, reader.uint32(), options, message.appDmSettings);
  5801.           break;
  5802.         default:
  5803.           let u = options.readUnknownField;
  5804.           if (u === "throw")
  5805.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5806.           let d = reader.skip(wireType);
  5807.           if (u !== false)
  5808.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5809.       }
  5810.     }
  5811.     return message;
  5812.   }
  5813.   internalBinaryWrite(message, writer, options) {
  5814.     if (message.appDmSettings)
  5815.       PreloadedUserSettings_ApplicationDMSettings.internalBinaryWrite(message.appDmSettings, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  5816.     let u = options.writeUnknownFields;
  5817.     if (u !== false)
  5818.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5819.     return writer;
  5820.   }
  5821. }
  5822. var PreloadedUserSettings_ApplicationSettings = new PreloadedUserSettings_ApplicationSettings$Type;
  5823.  
  5824. class PreloadedUserSettings_AllApplicationSettings$Type extends MessageType {
  5825.   constructor() {
  5826.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AllApplicationSettings", [
  5827.       { no: 1, name: "app_settings", kind: "map", K: 6, V: { kind: "message", T: () => PreloadedUserSettings_ApplicationSettings } }
  5828.     ]);
  5829.   }
  5830.   create(value) {
  5831.     const message = globalThis.Object.create(this.messagePrototype);
  5832.     message.appSettings = {};
  5833.     if (value !== undefined)
  5834.       reflectionMergePartial(this, message, value);
  5835.     return message;
  5836.   }
  5837.   internalBinaryRead(reader, length, options, target) {
  5838.     let message = target ?? this.create(), end = reader.pos + length;
  5839.     while (reader.pos < end) {
  5840.       let [fieldNo, wireType] = reader.tag();
  5841.       switch (fieldNo) {
  5842.         case 1:
  5843.           this.binaryReadMap1(message.appSettings, reader, options);
  5844.           break;
  5845.         default:
  5846.           let u = options.readUnknownField;
  5847.           if (u === "throw")
  5848.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5849.           let d = reader.skip(wireType);
  5850.           if (u !== false)
  5851.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5852.       }
  5853.     }
  5854.     return message;
  5855.   }
  5856.   binaryReadMap1(map, reader, options) {
  5857.     let len = reader.uint32(), end = reader.pos + len, key, val;
  5858.     while (reader.pos < end) {
  5859.       let [fieldNo, wireType] = reader.tag();
  5860.       switch (fieldNo) {
  5861.         case 1:
  5862.           key = reader.fixed64().toString();
  5863.           break;
  5864.         case 2:
  5865.           val = PreloadedUserSettings_ApplicationSettings.internalBinaryRead(reader, reader.uint32(), options);
  5866.           break;
  5867.         default:
  5868.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.PreloadedUserSettings.AllApplicationSettings.app_settings");
  5869.       }
  5870.     }
  5871.     map[key ?? "0"] = val ?? PreloadedUserSettings_ApplicationSettings.create();
  5872.   }
  5873.   internalBinaryWrite(message, writer, options) {
  5874.     for (let k of globalThis.Object.keys(message.appSettings)) {
  5875.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  5876.       writer.tag(2, WireType.LengthDelimited).fork();
  5877.       PreloadedUserSettings_ApplicationSettings.internalBinaryWrite(message.appSettings[k], writer, options);
  5878.       writer.join().join();
  5879.     }
  5880.     let u = options.writeUnknownFields;
  5881.     if (u !== false)
  5882.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5883.     return writer;
  5884.   }
  5885. }
  5886. var PreloadedUserSettings_AllApplicationSettings = new PreloadedUserSettings_AllApplicationSettings$Type;
  5887.  
  5888. class PreloadedUserSettings_AdsSettings$Type extends MessageType {
  5889.   constructor() {
  5890.     super("discord_protos.discord_users.v1.PreloadedUserSettings.AdsSettings", [
  5891.       { no: 1, name: "always_deliver", kind: "scalar", T: 8 }
  5892.     ]);
  5893.   }
  5894.   create(value) {
  5895.     const message = globalThis.Object.create(this.messagePrototype);
  5896.     message.alwaysDeliver = false;
  5897.     if (value !== undefined)
  5898.       reflectionMergePartial(this, message, value);
  5899.     return message;
  5900.   }
  5901.   internalBinaryRead(reader, length, options, target) {
  5902.     let message = target ?? this.create(), end = reader.pos + length;
  5903.     while (reader.pos < end) {
  5904.       let [fieldNo, wireType] = reader.tag();
  5905.       switch (fieldNo) {
  5906.         case 1:
  5907.           message.alwaysDeliver = reader.bool();
  5908.           break;
  5909.         default:
  5910.           let u = options.readUnknownField;
  5911.           if (u === "throw")
  5912.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  5913.           let d = reader.skip(wireType);
  5914.           if (u !== false)
  5915.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  5916.       }
  5917.     }
  5918.     return message;
  5919.   }
  5920.   internalBinaryWrite(message, writer, options) {
  5921.     if (message.alwaysDeliver !== false)
  5922.       writer.tag(1, WireType.Varint).bool(message.alwaysDeliver);
  5923.     let u = options.writeUnknownFields;
  5924.     if (u !== false)
  5925.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  5926.     return writer;
  5927.   }
  5928. }
  5929. var PreloadedUserSettings_AdsSettings = new PreloadedUserSettings_AdsSettings$Type;
  5930. // node_modules/discord-protos/src/discord_protos/discord_users/v1/FrecencyUserSettings.ts
  5931. var FrecencyUserSettings_GIFType;
  5932. ((FrecencyUserSettings_GIFType2) => {
  5933.   FrecencyUserSettings_GIFType2[FrecencyUserSettings_GIFType2["GIF_TYPE_NONE"] = 0] = "GIF_TYPE_NONE";
  5934.   FrecencyUserSettings_GIFType2[FrecencyUserSettings_GIFType2["GIF_TYPE_IMAGE"] = 1] = "GIF_TYPE_IMAGE";
  5935.   FrecencyUserSettings_GIFType2[FrecencyUserSettings_GIFType2["GIF_TYPE_VIDEO"] = 2] = "GIF_TYPE_VIDEO";
  5936. })(FrecencyUserSettings_GIFType ||= {});
  5937.  
  5938. class FrecencyUserSettings$Type extends MessageType {
  5939.   constructor() {
  5940.     super("discord_protos.discord_users.v1.FrecencyUserSettings", [
  5941.       { no: 1, name: "versions", kind: "message", T: () => FrecencyUserSettings_Versions },
  5942.       { no: 2, name: "favorite_gifs", kind: "message", T: () => FrecencyUserSettings_FavoriteGIFs },
  5943.       { no: 3, name: "favorite_stickers", kind: "message", T: () => FrecencyUserSettings_FavoriteStickers },
  5944.       { no: 4, name: "sticker_frecency", kind: "message", T: () => FrecencyUserSettings_StickerFrecency },
  5945.       { no: 5, name: "favorite_emojis", kind: "message", T: () => FrecencyUserSettings_FavoriteEmojis },
  5946.       { no: 6, name: "emoji_frecency", kind: "message", T: () => FrecencyUserSettings_EmojiFrecency },
  5947.       { no: 7, name: "application_command_frecency", kind: "message", T: () => FrecencyUserSettings_ApplicationCommandFrecency },
  5948.       { no: 8, name: "favorite_soundboard_sounds", kind: "message", T: () => FrecencyUserSettings_FavoriteSoundboardSounds },
  5949.       { no: 9, name: "application_frecency", kind: "message", T: () => FrecencyUserSettings_ApplicationFrecency },
  5950.       { no: 10, name: "heard_sound_frecency", kind: "message", T: () => FrecencyUserSettings_HeardSoundFrecency },
  5951.       { no: 11, name: "played_sound_frecency", kind: "message", T: () => FrecencyUserSettings_PlayedSoundFrecency },
  5952.       { no: 12, name: "guild_and_channel_frecency", kind: "message", T: () => FrecencyUserSettings_GuildAndChannelFrecency },
  5953.       { no: 13, name: "emoji_reaction_frecency", kind: "message", T: () => FrecencyUserSettings_EmojiFrecency }
  5954.     ]);
  5955.   }
  5956.   create(value) {
  5957.     const message = globalThis.Object.create(this.messagePrototype);
  5958.     if (value !== undefined)
  5959.       reflectionMergePartial(this, message, value);
  5960.     return message;
  5961.   }
  5962.   internalBinaryRead(reader, length, options, target) {
  5963.     let message = target ?? this.create(), end = reader.pos + length;
  5964.     while (reader.pos < end) {
  5965.       let [fieldNo, wireType] = reader.tag();
  5966.       switch (fieldNo) {
  5967.         case 1:
  5968.           message.versions = FrecencyUserSettings_Versions.internalBinaryRead(reader, reader.uint32(), options, message.versions);
  5969.           break;
  5970.         case 2:
  5971.           message.favoriteGifs = FrecencyUserSettings_FavoriteGIFs.internalBinaryRead(reader, reader.uint32(), options, message.favoriteGifs);
  5972.           break;
  5973.         case 3:
  5974.           message.favoriteStickers = FrecencyUserSettings_FavoriteStickers.internalBinaryRead(reader, reader.uint32(), options, message.favoriteStickers);
  5975.           break;
  5976.         case 4:
  5977.           message.stickerFrecency = FrecencyUserSettings_StickerFrecency.internalBinaryRead(reader, reader.uint32(), options, message.stickerFrecency);
  5978.           break;
  5979.         case 5:
  5980.           message.favoriteEmojis = FrecencyUserSettings_FavoriteEmojis.internalBinaryRead(reader, reader.uint32(), options, message.favoriteEmojis);
  5981.           break;
  5982.         case 6:
  5983.           message.emojiFrecency = FrecencyUserSettings_EmojiFrecency.internalBinaryRead(reader, reader.uint32(), options, message.emojiFrecency);
  5984.           break;
  5985.         case 7:
  5986.           message.applicationCommandFrecency = FrecencyUserSettings_ApplicationCommandFrecency.internalBinaryRead(reader, reader.uint32(), options, message.applicationCommandFrecency);
  5987.           break;
  5988.         case 8:
  5989.           message.favoriteSoundboardSounds = FrecencyUserSettings_FavoriteSoundboardSounds.internalBinaryRead(reader, reader.uint32(), options, message.favoriteSoundboardSounds);
  5990.           break;
  5991.         case 9:
  5992.           message.applicationFrecency = FrecencyUserSettings_ApplicationFrecency.internalBinaryRead(reader, reader.uint32(), options, message.applicationFrecency);
  5993.           break;
  5994.         case 10:
  5995.           message.heardSoundFrecency = FrecencyUserSettings_HeardSoundFrecency.internalBinaryRead(reader, reader.uint32(), options, message.heardSoundFrecency);
  5996.           break;
  5997.         case 11:
  5998.           message.playedSoundFrecency = FrecencyUserSettings_PlayedSoundFrecency.internalBinaryRead(reader, reader.uint32(), options, message.playedSoundFrecency);
  5999.           break;
  6000.         case 12:
  6001.           message.guildAndChannelFrecency = FrecencyUserSettings_GuildAndChannelFrecency.internalBinaryRead(reader, reader.uint32(), options, message.guildAndChannelFrecency);
  6002.           break;
  6003.         case 13:
  6004.           message.emojiReactionFrecency = FrecencyUserSettings_EmojiFrecency.internalBinaryRead(reader, reader.uint32(), options, message.emojiReactionFrecency);
  6005.           break;
  6006.         default:
  6007.           let u = options.readUnknownField;
  6008.           if (u === "throw")
  6009.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6010.           let d = reader.skip(wireType);
  6011.           if (u !== false)
  6012.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6013.       }
  6014.     }
  6015.     return message;
  6016.   }
  6017.   internalBinaryWrite(message, writer, options) {
  6018.     if (message.versions)
  6019.       FrecencyUserSettings_Versions.internalBinaryWrite(message.versions, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  6020.     if (message.favoriteGifs)
  6021.       FrecencyUserSettings_FavoriteGIFs.internalBinaryWrite(message.favoriteGifs, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  6022.     if (message.favoriteStickers)
  6023.       FrecencyUserSettings_FavoriteStickers.internalBinaryWrite(message.favoriteStickers, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  6024.     if (message.stickerFrecency)
  6025.       FrecencyUserSettings_StickerFrecency.internalBinaryWrite(message.stickerFrecency, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  6026.     if (message.favoriteEmojis)
  6027.       FrecencyUserSettings_FavoriteEmojis.internalBinaryWrite(message.favoriteEmojis, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  6028.     if (message.emojiFrecency)
  6029.       FrecencyUserSettings_EmojiFrecency.internalBinaryWrite(message.emojiFrecency, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  6030.     if (message.applicationCommandFrecency)
  6031.       FrecencyUserSettings_ApplicationCommandFrecency.internalBinaryWrite(message.applicationCommandFrecency, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
  6032.     if (message.favoriteSoundboardSounds)
  6033.       FrecencyUserSettings_FavoriteSoundboardSounds.internalBinaryWrite(message.favoriteSoundboardSounds, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  6034.     if (message.applicationFrecency)
  6035.       FrecencyUserSettings_ApplicationFrecency.internalBinaryWrite(message.applicationFrecency, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  6036.     if (message.heardSoundFrecency)
  6037.       FrecencyUserSettings_HeardSoundFrecency.internalBinaryWrite(message.heardSoundFrecency, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  6038.     if (message.playedSoundFrecency)
  6039.       FrecencyUserSettings_PlayedSoundFrecency.internalBinaryWrite(message.playedSoundFrecency, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  6040.     if (message.guildAndChannelFrecency)
  6041.       FrecencyUserSettings_GuildAndChannelFrecency.internalBinaryWrite(message.guildAndChannelFrecency, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
  6042.     if (message.emojiReactionFrecency)
  6043.       FrecencyUserSettings_EmojiFrecency.internalBinaryWrite(message.emojiReactionFrecency, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
  6044.     let u = options.writeUnknownFields;
  6045.     if (u !== false)
  6046.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6047.     return writer;
  6048.   }
  6049. }
  6050. var FrecencyUserSettings = new FrecencyUserSettings$Type;
  6051.  
  6052. class FrecencyUserSettings_Versions$Type extends MessageType {
  6053.   constructor() {
  6054.     super("discord_protos.discord_users.v1.FrecencyUserSettings.Versions", [
  6055.       { no: 1, name: "client_version", kind: "scalar", T: 13 },
  6056.       { no: 2, name: "server_version", kind: "scalar", T: 13 },
  6057.       { no: 3, name: "data_version", kind: "scalar", T: 13 }
  6058.     ]);
  6059.   }
  6060.   create(value) {
  6061.     const message = globalThis.Object.create(this.messagePrototype);
  6062.     message.clientVersion = 0;
  6063.     message.serverVersion = 0;
  6064.     message.dataVersion = 0;
  6065.     if (value !== undefined)
  6066.       reflectionMergePartial(this, message, value);
  6067.     return message;
  6068.   }
  6069.   internalBinaryRead(reader, length, options, target) {
  6070.     let message = target ?? this.create(), end = reader.pos + length;
  6071.     while (reader.pos < end) {
  6072.       let [fieldNo, wireType] = reader.tag();
  6073.       switch (fieldNo) {
  6074.         case 1:
  6075.           message.clientVersion = reader.uint32();
  6076.           break;
  6077.         case 2:
  6078.           message.serverVersion = reader.uint32();
  6079.           break;
  6080.         case 3:
  6081.           message.dataVersion = reader.uint32();
  6082.           break;
  6083.         default:
  6084.           let u = options.readUnknownField;
  6085.           if (u === "throw")
  6086.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6087.           let d = reader.skip(wireType);
  6088.           if (u !== false)
  6089.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6090.       }
  6091.     }
  6092.     return message;
  6093.   }
  6094.   internalBinaryWrite(message, writer, options) {
  6095.     if (message.clientVersion !== 0)
  6096.       writer.tag(1, WireType.Varint).uint32(message.clientVersion);
  6097.     if (message.serverVersion !== 0)
  6098.       writer.tag(2, WireType.Varint).uint32(message.serverVersion);
  6099.     if (message.dataVersion !== 0)
  6100.       writer.tag(3, WireType.Varint).uint32(message.dataVersion);
  6101.     let u = options.writeUnknownFields;
  6102.     if (u !== false)
  6103.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6104.     return writer;
  6105.   }
  6106. }
  6107. var FrecencyUserSettings_Versions = new FrecencyUserSettings_Versions$Type;
  6108.  
  6109. class FrecencyUserSettings_FavoriteGIF$Type extends MessageType {
  6110.   constructor() {
  6111.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteGIF", [
  6112.       { no: 1, name: "format", kind: "enum", T: () => ["discord_protos.discord_users.v1.FrecencyUserSettings.GIFType", FrecencyUserSettings_GIFType] },
  6113.       { no: 2, name: "src", kind: "scalar", T: 9 },
  6114.       { no: 3, name: "width", kind: "scalar", T: 13 },
  6115.       { no: 4, name: "height", kind: "scalar", T: 13 },
  6116.       { no: 5, name: "order", kind: "scalar", T: 13 }
  6117.     ]);
  6118.   }
  6119.   create(value) {
  6120.     const message = globalThis.Object.create(this.messagePrototype);
  6121.     message.format = 0;
  6122.     message.src = "";
  6123.     message.width = 0;
  6124.     message.height = 0;
  6125.     message.order = 0;
  6126.     if (value !== undefined)
  6127.       reflectionMergePartial(this, message, value);
  6128.     return message;
  6129.   }
  6130.   internalBinaryRead(reader, length, options, target) {
  6131.     let message = target ?? this.create(), end = reader.pos + length;
  6132.     while (reader.pos < end) {
  6133.       let [fieldNo, wireType] = reader.tag();
  6134.       switch (fieldNo) {
  6135.         case 1:
  6136.           message.format = reader.int32();
  6137.           break;
  6138.         case 2:
  6139.           message.src = reader.string();
  6140.           break;
  6141.         case 3:
  6142.           message.width = reader.uint32();
  6143.           break;
  6144.         case 4:
  6145.           message.height = reader.uint32();
  6146.           break;
  6147.         case 5:
  6148.           message.order = reader.uint32();
  6149.           break;
  6150.         default:
  6151.           let u = options.readUnknownField;
  6152.           if (u === "throw")
  6153.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6154.           let d = reader.skip(wireType);
  6155.           if (u !== false)
  6156.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6157.       }
  6158.     }
  6159.     return message;
  6160.   }
  6161.   internalBinaryWrite(message, writer, options) {
  6162.     if (message.format !== 0)
  6163.       writer.tag(1, WireType.Varint).int32(message.format);
  6164.     if (message.src !== "")
  6165.       writer.tag(2, WireType.LengthDelimited).string(message.src);
  6166.     if (message.width !== 0)
  6167.       writer.tag(3, WireType.Varint).uint32(message.width);
  6168.     if (message.height !== 0)
  6169.       writer.tag(4, WireType.Varint).uint32(message.height);
  6170.     if (message.order !== 0)
  6171.       writer.tag(5, WireType.Varint).uint32(message.order);
  6172.     let u = options.writeUnknownFields;
  6173.     if (u !== false)
  6174.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6175.     return writer;
  6176.   }
  6177. }
  6178. var FrecencyUserSettings_FavoriteGIF = new FrecencyUserSettings_FavoriteGIF$Type;
  6179.  
  6180. class FrecencyUserSettings_FavoriteGIFs$Type extends MessageType {
  6181.   constructor() {
  6182.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteGIFs", [
  6183.       { no: 1, name: "gifs", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FavoriteGIF } },
  6184.       { no: 2, name: "hide_tooltip", kind: "scalar", T: 8 }
  6185.     ]);
  6186.   }
  6187.   create(value) {
  6188.     const message = globalThis.Object.create(this.messagePrototype);
  6189.     message.gifs = {};
  6190.     message.hideTooltip = false;
  6191.     if (value !== undefined)
  6192.       reflectionMergePartial(this, message, value);
  6193.     return message;
  6194.   }
  6195.   internalBinaryRead(reader, length, options, target) {
  6196.     let message = target ?? this.create(), end = reader.pos + length;
  6197.     while (reader.pos < end) {
  6198.       let [fieldNo, wireType] = reader.tag();
  6199.       switch (fieldNo) {
  6200.         case 1:
  6201.           this.binaryReadMap1(message.gifs, reader, options);
  6202.           break;
  6203.         case 2:
  6204.           message.hideTooltip = reader.bool();
  6205.           break;
  6206.         default:
  6207.           let u = options.readUnknownField;
  6208.           if (u === "throw")
  6209.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6210.           let d = reader.skip(wireType);
  6211.           if (u !== false)
  6212.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6213.       }
  6214.     }
  6215.     return message;
  6216.   }
  6217.   binaryReadMap1(map, reader, options) {
  6218.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6219.     while (reader.pos < end) {
  6220.       let [fieldNo, wireType] = reader.tag();
  6221.       switch (fieldNo) {
  6222.         case 1:
  6223.           key = reader.string();
  6224.           break;
  6225.         case 2:
  6226.           val = FrecencyUserSettings_FavoriteGIF.internalBinaryRead(reader, reader.uint32(), options);
  6227.           break;
  6228.         default:
  6229.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteGIFs.gifs");
  6230.       }
  6231.     }
  6232.     map[key ?? ""] = val ?? FrecencyUserSettings_FavoriteGIF.create();
  6233.   }
  6234.   internalBinaryWrite(message, writer, options) {
  6235.     for (let k of globalThis.Object.keys(message.gifs)) {
  6236.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6237.       writer.tag(2, WireType.LengthDelimited).fork();
  6238.       FrecencyUserSettings_FavoriteGIF.internalBinaryWrite(message.gifs[k], writer, options);
  6239.       writer.join().join();
  6240.     }
  6241.     if (message.hideTooltip !== false)
  6242.       writer.tag(2, WireType.Varint).bool(message.hideTooltip);
  6243.     let u = options.writeUnknownFields;
  6244.     if (u !== false)
  6245.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6246.     return writer;
  6247.   }
  6248. }
  6249. var FrecencyUserSettings_FavoriteGIFs = new FrecencyUserSettings_FavoriteGIFs$Type;
  6250.  
  6251. class FrecencyUserSettings_FavoriteStickers$Type extends MessageType {
  6252.   constructor() {
  6253.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteStickers", [
  6254.       { no: 1, name: "sticker_ids", kind: "scalar", repeat: 1, T: 6, L: 0 }
  6255.     ]);
  6256.   }
  6257.   create(value) {
  6258.     const message = globalThis.Object.create(this.messagePrototype);
  6259.     message.stickerIds = [];
  6260.     if (value !== undefined)
  6261.       reflectionMergePartial(this, message, value);
  6262.     return message;
  6263.   }
  6264.   internalBinaryRead(reader, length, options, target) {
  6265.     let message = target ?? this.create(), end = reader.pos + length;
  6266.     while (reader.pos < end) {
  6267.       let [fieldNo, wireType] = reader.tag();
  6268.       switch (fieldNo) {
  6269.         case 1:
  6270.           if (wireType === WireType.LengthDelimited)
  6271.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  6272.               message.stickerIds.push(reader.fixed64().toBigInt());
  6273.           else
  6274.             message.stickerIds.push(reader.fixed64().toBigInt());
  6275.           break;
  6276.         default:
  6277.           let u = options.readUnknownField;
  6278.           if (u === "throw")
  6279.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6280.           let d = reader.skip(wireType);
  6281.           if (u !== false)
  6282.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6283.       }
  6284.     }
  6285.     return message;
  6286.   }
  6287.   internalBinaryWrite(message, writer, options) {
  6288.     if (message.stickerIds.length) {
  6289.       writer.tag(1, WireType.LengthDelimited).fork();
  6290.       for (let i = 0;i < message.stickerIds.length; i++)
  6291.         writer.fixed64(message.stickerIds[i]);
  6292.       writer.join();
  6293.     }
  6294.     let u = options.writeUnknownFields;
  6295.     if (u !== false)
  6296.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6297.     return writer;
  6298.   }
  6299. }
  6300. var FrecencyUserSettings_FavoriteStickers = new FrecencyUserSettings_FavoriteStickers$Type;
  6301.  
  6302. class FrecencyUserSettings_FrecencyItem$Type extends MessageType {
  6303.   constructor() {
  6304.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FrecencyItem", [
  6305.       { no: 1, name: "total_uses", kind: "scalar", T: 13 },
  6306.       { no: 2, name: "recent_uses", kind: "scalar", repeat: 1, T: 4, L: 0 },
  6307.       { no: 3, name: "frecency", kind: "scalar", T: 5 },
  6308.       { no: 4, name: "score", kind: "scalar", T: 5 }
  6309.     ]);
  6310.   }
  6311.   create(value) {
  6312.     const message = globalThis.Object.create(this.messagePrototype);
  6313.     message.totalUses = 0;
  6314.     message.recentUses = [];
  6315.     message.frecency = 0;
  6316.     message.score = 0;
  6317.     if (value !== undefined)
  6318.       reflectionMergePartial(this, message, value);
  6319.     return message;
  6320.   }
  6321.   internalBinaryRead(reader, length, options, target) {
  6322.     let message = target ?? this.create(), end = reader.pos + length;
  6323.     while (reader.pos < end) {
  6324.       let [fieldNo, wireType] = reader.tag();
  6325.       switch (fieldNo) {
  6326.         case 1:
  6327.           message.totalUses = reader.uint32();
  6328.           break;
  6329.         case 2:
  6330.           if (wireType === WireType.LengthDelimited)
  6331.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  6332.               message.recentUses.push(reader.uint64().toBigInt());
  6333.           else
  6334.             message.recentUses.push(reader.uint64().toBigInt());
  6335.           break;
  6336.         case 3:
  6337.           message.frecency = reader.int32();
  6338.           break;
  6339.         case 4:
  6340.           message.score = reader.int32();
  6341.           break;
  6342.         default:
  6343.           let u = options.readUnknownField;
  6344.           if (u === "throw")
  6345.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6346.           let d = reader.skip(wireType);
  6347.           if (u !== false)
  6348.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6349.       }
  6350.     }
  6351.     return message;
  6352.   }
  6353.   internalBinaryWrite(message, writer, options) {
  6354.     if (message.totalUses !== 0)
  6355.       writer.tag(1, WireType.Varint).uint32(message.totalUses);
  6356.     if (message.recentUses.length) {
  6357.       writer.tag(2, WireType.LengthDelimited).fork();
  6358.       for (let i = 0;i < message.recentUses.length; i++)
  6359.         writer.uint64(message.recentUses[i]);
  6360.       writer.join();
  6361.     }
  6362.     if (message.frecency !== 0)
  6363.       writer.tag(3, WireType.Varint).int32(message.frecency);
  6364.     if (message.score !== 0)
  6365.       writer.tag(4, WireType.Varint).int32(message.score);
  6366.     let u = options.writeUnknownFields;
  6367.     if (u !== false)
  6368.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6369.     return writer;
  6370.   }
  6371. }
  6372. var FrecencyUserSettings_FrecencyItem = new FrecencyUserSettings_FrecencyItem$Type;
  6373.  
  6374. class FrecencyUserSettings_StickerFrecency$Type extends MessageType {
  6375.   constructor() {
  6376.     super("discord_protos.discord_users.v1.FrecencyUserSettings.StickerFrecency", [
  6377.       { no: 1, name: "stickers", kind: "map", K: 6, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6378.     ]);
  6379.   }
  6380.   create(value) {
  6381.     const message = globalThis.Object.create(this.messagePrototype);
  6382.     message.stickers = {};
  6383.     if (value !== undefined)
  6384.       reflectionMergePartial(this, message, value);
  6385.     return message;
  6386.   }
  6387.   internalBinaryRead(reader, length, options, target) {
  6388.     let message = target ?? this.create(), end = reader.pos + length;
  6389.     while (reader.pos < end) {
  6390.       let [fieldNo, wireType] = reader.tag();
  6391.       switch (fieldNo) {
  6392.         case 1:
  6393.           this.binaryReadMap1(message.stickers, reader, options);
  6394.           break;
  6395.         default:
  6396.           let u = options.readUnknownField;
  6397.           if (u === "throw")
  6398.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6399.           let d = reader.skip(wireType);
  6400.           if (u !== false)
  6401.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6402.       }
  6403.     }
  6404.     return message;
  6405.   }
  6406.   binaryReadMap1(map, reader, options) {
  6407.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6408.     while (reader.pos < end) {
  6409.       let [fieldNo, wireType] = reader.tag();
  6410.       switch (fieldNo) {
  6411.         case 1:
  6412.           key = reader.fixed64().toString();
  6413.           break;
  6414.         case 2:
  6415.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6416.           break;
  6417.         default:
  6418.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.StickerFrecency.stickers");
  6419.       }
  6420.     }
  6421.     map[key ?? "0"] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6422.   }
  6423.   internalBinaryWrite(message, writer, options) {
  6424.     for (let k of globalThis.Object.keys(message.stickers)) {
  6425.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  6426.       writer.tag(2, WireType.LengthDelimited).fork();
  6427.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.stickers[k], writer, options);
  6428.       writer.join().join();
  6429.     }
  6430.     let u = options.writeUnknownFields;
  6431.     if (u !== false)
  6432.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6433.     return writer;
  6434.   }
  6435. }
  6436. var FrecencyUserSettings_StickerFrecency = new FrecencyUserSettings_StickerFrecency$Type;
  6437.  
  6438. class FrecencyUserSettings_FavoriteEmojis$Type extends MessageType {
  6439.   constructor() {
  6440.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteEmojis", [
  6441.       { no: 1, name: "emojis", kind: "scalar", repeat: 2, T: 9 }
  6442.     ]);
  6443.   }
  6444.   create(value) {
  6445.     const message = globalThis.Object.create(this.messagePrototype);
  6446.     message.emojis = [];
  6447.     if (value !== undefined)
  6448.       reflectionMergePartial(this, message, value);
  6449.     return message;
  6450.   }
  6451.   internalBinaryRead(reader, length, options, target) {
  6452.     let message = target ?? this.create(), end = reader.pos + length;
  6453.     while (reader.pos < end) {
  6454.       let [fieldNo, wireType] = reader.tag();
  6455.       switch (fieldNo) {
  6456.         case 1:
  6457.           message.emojis.push(reader.string());
  6458.           break;
  6459.         default:
  6460.           let u = options.readUnknownField;
  6461.           if (u === "throw")
  6462.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6463.           let d = reader.skip(wireType);
  6464.           if (u !== false)
  6465.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6466.       }
  6467.     }
  6468.     return message;
  6469.   }
  6470.   internalBinaryWrite(message, writer, options) {
  6471.     for (let i = 0;i < message.emojis.length; i++)
  6472.       writer.tag(1, WireType.LengthDelimited).string(message.emojis[i]);
  6473.     let u = options.writeUnknownFields;
  6474.     if (u !== false)
  6475.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6476.     return writer;
  6477.   }
  6478. }
  6479. var FrecencyUserSettings_FavoriteEmojis = new FrecencyUserSettings_FavoriteEmojis$Type;
  6480.  
  6481. class FrecencyUserSettings_EmojiFrecency$Type extends MessageType {
  6482.   constructor() {
  6483.     super("discord_protos.discord_users.v1.FrecencyUserSettings.EmojiFrecency", [
  6484.       { no: 1, name: "emojis", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6485.     ]);
  6486.   }
  6487.   create(value) {
  6488.     const message = globalThis.Object.create(this.messagePrototype);
  6489.     message.emojis = {};
  6490.     if (value !== undefined)
  6491.       reflectionMergePartial(this, message, value);
  6492.     return message;
  6493.   }
  6494.   internalBinaryRead(reader, length, options, target) {
  6495.     let message = target ?? this.create(), end = reader.pos + length;
  6496.     while (reader.pos < end) {
  6497.       let [fieldNo, wireType] = reader.tag();
  6498.       switch (fieldNo) {
  6499.         case 1:
  6500.           this.binaryReadMap1(message.emojis, reader, options);
  6501.           break;
  6502.         default:
  6503.           let u = options.readUnknownField;
  6504.           if (u === "throw")
  6505.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6506.           let d = reader.skip(wireType);
  6507.           if (u !== false)
  6508.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6509.       }
  6510.     }
  6511.     return message;
  6512.   }
  6513.   binaryReadMap1(map, reader, options) {
  6514.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6515.     while (reader.pos < end) {
  6516.       let [fieldNo, wireType] = reader.tag();
  6517.       switch (fieldNo) {
  6518.         case 1:
  6519.           key = reader.string();
  6520.           break;
  6521.         case 2:
  6522.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6523.           break;
  6524.         default:
  6525.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.EmojiFrecency.emojis");
  6526.       }
  6527.     }
  6528.     map[key ?? ""] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6529.   }
  6530.   internalBinaryWrite(message, writer, options) {
  6531.     for (let k of globalThis.Object.keys(message.emojis)) {
  6532.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6533.       writer.tag(2, WireType.LengthDelimited).fork();
  6534.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.emojis[k], writer, options);
  6535.       writer.join().join();
  6536.     }
  6537.     let u = options.writeUnknownFields;
  6538.     if (u !== false)
  6539.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6540.     return writer;
  6541.   }
  6542. }
  6543. var FrecencyUserSettings_EmojiFrecency = new FrecencyUserSettings_EmojiFrecency$Type;
  6544.  
  6545. class FrecencyUserSettings_ApplicationCommandFrecency$Type extends MessageType {
  6546.   constructor() {
  6547.     super("discord_protos.discord_users.v1.FrecencyUserSettings.ApplicationCommandFrecency", [
  6548.       { no: 1, name: "application_commands", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6549.     ]);
  6550.   }
  6551.   create(value) {
  6552.     const message = globalThis.Object.create(this.messagePrototype);
  6553.     message.applicationCommands = {};
  6554.     if (value !== undefined)
  6555.       reflectionMergePartial(this, message, value);
  6556.     return message;
  6557.   }
  6558.   internalBinaryRead(reader, length, options, target) {
  6559.     let message = target ?? this.create(), end = reader.pos + length;
  6560.     while (reader.pos < end) {
  6561.       let [fieldNo, wireType] = reader.tag();
  6562.       switch (fieldNo) {
  6563.         case 1:
  6564.           this.binaryReadMap1(message.applicationCommands, reader, options);
  6565.           break;
  6566.         default:
  6567.           let u = options.readUnknownField;
  6568.           if (u === "throw")
  6569.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6570.           let d = reader.skip(wireType);
  6571.           if (u !== false)
  6572.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6573.       }
  6574.     }
  6575.     return message;
  6576.   }
  6577.   binaryReadMap1(map, reader, options) {
  6578.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6579.     while (reader.pos < end) {
  6580.       let [fieldNo, wireType] = reader.tag();
  6581.       switch (fieldNo) {
  6582.         case 1:
  6583.           key = reader.string();
  6584.           break;
  6585.         case 2:
  6586.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6587.           break;
  6588.         default:
  6589.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.ApplicationCommandFrecency.application_commands");
  6590.       }
  6591.     }
  6592.     map[key ?? ""] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6593.   }
  6594.   internalBinaryWrite(message, writer, options) {
  6595.     for (let k of globalThis.Object.keys(message.applicationCommands)) {
  6596.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6597.       writer.tag(2, WireType.LengthDelimited).fork();
  6598.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.applicationCommands[k], writer, options);
  6599.       writer.join().join();
  6600.     }
  6601.     let u = options.writeUnknownFields;
  6602.     if (u !== false)
  6603.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6604.     return writer;
  6605.   }
  6606. }
  6607. var FrecencyUserSettings_ApplicationCommandFrecency = new FrecencyUserSettings_ApplicationCommandFrecency$Type;
  6608.  
  6609. class FrecencyUserSettings_FavoriteSoundboardSounds$Type extends MessageType {
  6610.   constructor() {
  6611.     super("discord_protos.discord_users.v1.FrecencyUserSettings.FavoriteSoundboardSounds", [
  6612.       { no: 1, name: "sound_ids", kind: "scalar", repeat: 1, T: 6, L: 0 }
  6613.     ]);
  6614.   }
  6615.   create(value) {
  6616.     const message = globalThis.Object.create(this.messagePrototype);
  6617.     message.soundIds = [];
  6618.     if (value !== undefined)
  6619.       reflectionMergePartial(this, message, value);
  6620.     return message;
  6621.   }
  6622.   internalBinaryRead(reader, length, options, target) {
  6623.     let message = target ?? this.create(), end = reader.pos + length;
  6624.     while (reader.pos < end) {
  6625.       let [fieldNo, wireType] = reader.tag();
  6626.       switch (fieldNo) {
  6627.         case 1:
  6628.           if (wireType === WireType.LengthDelimited)
  6629.             for (let e = reader.int32() + reader.pos;reader.pos < e; )
  6630.               message.soundIds.push(reader.fixed64().toBigInt());
  6631.           else
  6632.             message.soundIds.push(reader.fixed64().toBigInt());
  6633.           break;
  6634.         default:
  6635.           let u = options.readUnknownField;
  6636.           if (u === "throw")
  6637.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6638.           let d = reader.skip(wireType);
  6639.           if (u !== false)
  6640.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6641.       }
  6642.     }
  6643.     return message;
  6644.   }
  6645.   internalBinaryWrite(message, writer, options) {
  6646.     if (message.soundIds.length) {
  6647.       writer.tag(1, WireType.LengthDelimited).fork();
  6648.       for (let i = 0;i < message.soundIds.length; i++)
  6649.         writer.fixed64(message.soundIds[i]);
  6650.       writer.join();
  6651.     }
  6652.     let u = options.writeUnknownFields;
  6653.     if (u !== false)
  6654.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6655.     return writer;
  6656.   }
  6657. }
  6658. var FrecencyUserSettings_FavoriteSoundboardSounds = new FrecencyUserSettings_FavoriteSoundboardSounds$Type;
  6659.  
  6660. class FrecencyUserSettings_ApplicationFrecency$Type extends MessageType {
  6661.   constructor() {
  6662.     super("discord_protos.discord_users.v1.FrecencyUserSettings.ApplicationFrecency", [
  6663.       { no: 1, name: "applications", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6664.     ]);
  6665.   }
  6666.   create(value) {
  6667.     const message = globalThis.Object.create(this.messagePrototype);
  6668.     message.applications = {};
  6669.     if (value !== undefined)
  6670.       reflectionMergePartial(this, message, value);
  6671.     return message;
  6672.   }
  6673.   internalBinaryRead(reader, length, options, target) {
  6674.     let message = target ?? this.create(), end = reader.pos + length;
  6675.     while (reader.pos < end) {
  6676.       let [fieldNo, wireType] = reader.tag();
  6677.       switch (fieldNo) {
  6678.         case 1:
  6679.           this.binaryReadMap1(message.applications, reader, options);
  6680.           break;
  6681.         default:
  6682.           let u = options.readUnknownField;
  6683.           if (u === "throw")
  6684.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6685.           let d = reader.skip(wireType);
  6686.           if (u !== false)
  6687.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6688.       }
  6689.     }
  6690.     return message;
  6691.   }
  6692.   binaryReadMap1(map, reader, options) {
  6693.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6694.     while (reader.pos < end) {
  6695.       let [fieldNo, wireType] = reader.tag();
  6696.       switch (fieldNo) {
  6697.         case 1:
  6698.           key = reader.string();
  6699.           break;
  6700.         case 2:
  6701.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6702.           break;
  6703.         default:
  6704.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.ApplicationFrecency.applications");
  6705.       }
  6706.     }
  6707.     map[key ?? ""] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6708.   }
  6709.   internalBinaryWrite(message, writer, options) {
  6710.     for (let k of globalThis.Object.keys(message.applications)) {
  6711.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6712.       writer.tag(2, WireType.LengthDelimited).fork();
  6713.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.applications[k], writer, options);
  6714.       writer.join().join();
  6715.     }
  6716.     let u = options.writeUnknownFields;
  6717.     if (u !== false)
  6718.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6719.     return writer;
  6720.   }
  6721. }
  6722. var FrecencyUserSettings_ApplicationFrecency = new FrecencyUserSettings_ApplicationFrecency$Type;
  6723.  
  6724. class FrecencyUserSettings_HeardSoundFrecency$Type extends MessageType {
  6725.   constructor() {
  6726.     super("discord_protos.discord_users.v1.FrecencyUserSettings.HeardSoundFrecency", [
  6727.       { no: 1, name: "heard_sounds", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6728.     ]);
  6729.   }
  6730.   create(value) {
  6731.     const message = globalThis.Object.create(this.messagePrototype);
  6732.     message.heardSounds = {};
  6733.     if (value !== undefined)
  6734.       reflectionMergePartial(this, message, value);
  6735.     return message;
  6736.   }
  6737.   internalBinaryRead(reader, length, options, target) {
  6738.     let message = target ?? this.create(), end = reader.pos + length;
  6739.     while (reader.pos < end) {
  6740.       let [fieldNo, wireType] = reader.tag();
  6741.       switch (fieldNo) {
  6742.         case 1:
  6743.           this.binaryReadMap1(message.heardSounds, reader, options);
  6744.           break;
  6745.         default:
  6746.           let u = options.readUnknownField;
  6747.           if (u === "throw")
  6748.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6749.           let d = reader.skip(wireType);
  6750.           if (u !== false)
  6751.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6752.       }
  6753.     }
  6754.     return message;
  6755.   }
  6756.   binaryReadMap1(map, reader, options) {
  6757.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6758.     while (reader.pos < end) {
  6759.       let [fieldNo, wireType] = reader.tag();
  6760.       switch (fieldNo) {
  6761.         case 1:
  6762.           key = reader.string();
  6763.           break;
  6764.         case 2:
  6765.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6766.           break;
  6767.         default:
  6768.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.HeardSoundFrecency.heard_sounds");
  6769.       }
  6770.     }
  6771.     map[key ?? ""] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6772.   }
  6773.   internalBinaryWrite(message, writer, options) {
  6774.     for (let k of globalThis.Object.keys(message.heardSounds)) {
  6775.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6776.       writer.tag(2, WireType.LengthDelimited).fork();
  6777.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.heardSounds[k], writer, options);
  6778.       writer.join().join();
  6779.     }
  6780.     let u = options.writeUnknownFields;
  6781.     if (u !== false)
  6782.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6783.     return writer;
  6784.   }
  6785. }
  6786. var FrecencyUserSettings_HeardSoundFrecency = new FrecencyUserSettings_HeardSoundFrecency$Type;
  6787.  
  6788. class FrecencyUserSettings_PlayedSoundFrecency$Type extends MessageType {
  6789.   constructor() {
  6790.     super("discord_protos.discord_users.v1.FrecencyUserSettings.PlayedSoundFrecency", [
  6791.       { no: 1, name: "played_sounds", kind: "map", K: 9, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6792.     ]);
  6793.   }
  6794.   create(value) {
  6795.     const message = globalThis.Object.create(this.messagePrototype);
  6796.     message.playedSounds = {};
  6797.     if (value !== undefined)
  6798.       reflectionMergePartial(this, message, value);
  6799.     return message;
  6800.   }
  6801.   internalBinaryRead(reader, length, options, target) {
  6802.     let message = target ?? this.create(), end = reader.pos + length;
  6803.     while (reader.pos < end) {
  6804.       let [fieldNo, wireType] = reader.tag();
  6805.       switch (fieldNo) {
  6806.         case 1:
  6807.           this.binaryReadMap1(message.playedSounds, reader, options);
  6808.           break;
  6809.         default:
  6810.           let u = options.readUnknownField;
  6811.           if (u === "throw")
  6812.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6813.           let d = reader.skip(wireType);
  6814.           if (u !== false)
  6815.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6816.       }
  6817.     }
  6818.     return message;
  6819.   }
  6820.   binaryReadMap1(map, reader, options) {
  6821.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6822.     while (reader.pos < end) {
  6823.       let [fieldNo, wireType] = reader.tag();
  6824.       switch (fieldNo) {
  6825.         case 1:
  6826.           key = reader.string();
  6827.           break;
  6828.         case 2:
  6829.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6830.           break;
  6831.         default:
  6832.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.PlayedSoundFrecency.played_sounds");
  6833.       }
  6834.     }
  6835.     map[key ?? ""] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6836.   }
  6837.   internalBinaryWrite(message, writer, options) {
  6838.     for (let k of globalThis.Object.keys(message.playedSounds)) {
  6839.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
  6840.       writer.tag(2, WireType.LengthDelimited).fork();
  6841.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.playedSounds[k], writer, options);
  6842.       writer.join().join();
  6843.     }
  6844.     let u = options.writeUnknownFields;
  6845.     if (u !== false)
  6846.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6847.     return writer;
  6848.   }
  6849. }
  6850. var FrecencyUserSettings_PlayedSoundFrecency = new FrecencyUserSettings_PlayedSoundFrecency$Type;
  6851.  
  6852. class FrecencyUserSettings_GuildAndChannelFrecency$Type extends MessageType {
  6853.   constructor() {
  6854.     super("discord_protos.discord_users.v1.FrecencyUserSettings.GuildAndChannelFrecency", [
  6855.       { no: 1, name: "guild_and_channels", kind: "map", K: 6, V: { kind: "message", T: () => FrecencyUserSettings_FrecencyItem } }
  6856.     ]);
  6857.   }
  6858.   create(value) {
  6859.     const message = globalThis.Object.create(this.messagePrototype);
  6860.     message.guildAndChannels = {};
  6861.     if (value !== undefined)
  6862.       reflectionMergePartial(this, message, value);
  6863.     return message;
  6864.   }
  6865.   internalBinaryRead(reader, length, options, target) {
  6866.     let message = target ?? this.create(), end = reader.pos + length;
  6867.     while (reader.pos < end) {
  6868.       let [fieldNo, wireType] = reader.tag();
  6869.       switch (fieldNo) {
  6870.         case 1:
  6871.           this.binaryReadMap1(message.guildAndChannels, reader, options);
  6872.           break;
  6873.         default:
  6874.           let u = options.readUnknownField;
  6875.           if (u === "throw")
  6876.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6877.           let d = reader.skip(wireType);
  6878.           if (u !== false)
  6879.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6880.       }
  6881.     }
  6882.     return message;
  6883.   }
  6884.   binaryReadMap1(map, reader, options) {
  6885.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6886.     while (reader.pos < end) {
  6887.       let [fieldNo, wireType] = reader.tag();
  6888.       switch (fieldNo) {
  6889.         case 1:
  6890.           key = reader.fixed64().toString();
  6891.           break;
  6892.         case 2:
  6893.           val = FrecencyUserSettings_FrecencyItem.internalBinaryRead(reader, reader.uint32(), options);
  6894.           break;
  6895.         default:
  6896.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_users.v1.FrecencyUserSettings.GuildAndChannelFrecency.guild_and_channels");
  6897.       }
  6898.     }
  6899.     map[key ?? "0"] = val ?? FrecencyUserSettings_FrecencyItem.create();
  6900.   }
  6901.   internalBinaryWrite(message, writer, options) {
  6902.     for (let k of globalThis.Object.keys(message.guildAndChannels)) {
  6903.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.Bit64).fixed64(k);
  6904.       writer.tag(2, WireType.LengthDelimited).fork();
  6905.       FrecencyUserSettings_FrecencyItem.internalBinaryWrite(message.guildAndChannels[k], writer, options);
  6906.       writer.join().join();
  6907.     }
  6908.     let u = options.writeUnknownFields;
  6909.     if (u !== false)
  6910.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6911.     return writer;
  6912.   }
  6913. }
  6914. var FrecencyUserSettings_GuildAndChannelFrecency = new FrecencyUserSettings_GuildAndChannelFrecency$Type;
  6915. // node_modules/discord-protos/src/discord_protos/discord_kkv_store_value_models/v1/ApplicationUserRoleConnection.ts
  6916. class ApplicationUserRoleConnection$Type extends MessageType {
  6917.   constructor() {
  6918.     super("discord_protos.discord_kkv_store_value_models.v1.ApplicationUserRoleConnection", [
  6919.       { no: 1, name: "metadata", kind: "map", K: 9, V: { kind: "scalar", T: 9 } },
  6920.       { no: 2, name: "platform_name", kind: "scalar", T: 9 },
  6921.       { no: 3, name: "platform_username", kind: "scalar", T: 9 },
  6922.       { no: 4, name: "version", kind: "scalar", T: 6, L: 0 }
  6923.     ]);
  6924.   }
  6925.   create(value) {
  6926.     const message = globalThis.Object.create(this.messagePrototype);
  6927.     message.metadata = {};
  6928.     message.platformName = "";
  6929.     message.platformUsername = "";
  6930.     message.version = 0n;
  6931.     if (value !== undefined)
  6932.       reflectionMergePartial(this, message, value);
  6933.     return message;
  6934.   }
  6935.   internalBinaryRead(reader, length, options, target) {
  6936.     let message = target ?? this.create(), end = reader.pos + length;
  6937.     while (reader.pos < end) {
  6938.       let [fieldNo, wireType] = reader.tag();
  6939.       switch (fieldNo) {
  6940.         case 1:
  6941.           this.binaryReadMap1(message.metadata, reader, options);
  6942.           break;
  6943.         case 2:
  6944.           message.platformName = reader.string();
  6945.           break;
  6946.         case 3:
  6947.           message.platformUsername = reader.string();
  6948.           break;
  6949.         case 4:
  6950.           message.version = reader.fixed64().toBigInt();
  6951.           break;
  6952.         default:
  6953.           let u = options.readUnknownField;
  6954.           if (u === "throw")
  6955.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  6956.           let d = reader.skip(wireType);
  6957.           if (u !== false)
  6958.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  6959.       }
  6960.     }
  6961.     return message;
  6962.   }
  6963.   binaryReadMap1(map, reader, options) {
  6964.     let len = reader.uint32(), end = reader.pos + len, key, val;
  6965.     while (reader.pos < end) {
  6966.       let [fieldNo, wireType] = reader.tag();
  6967.       switch (fieldNo) {
  6968.         case 1:
  6969.           key = reader.string();
  6970.           break;
  6971.         case 2:
  6972.           val = reader.string();
  6973.           break;
  6974.         default:
  6975.           throw new globalThis.Error("unknown map entry field for field discord_protos.discord_kkv_store_value_models.v1.ApplicationUserRoleConnection.metadata");
  6976.       }
  6977.     }
  6978.     map[key ?? ""] = val ?? "";
  6979.   }
  6980.   internalBinaryWrite(message, writer, options) {
  6981.     for (let k of globalThis.Object.keys(message.metadata))
  6982.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.metadata[k]).join();
  6983.     if (message.platformName !== "")
  6984.       writer.tag(2, WireType.LengthDelimited).string(message.platformName);
  6985.     if (message.platformUsername !== "")
  6986.       writer.tag(3, WireType.LengthDelimited).string(message.platformUsername);
  6987.     if (message.version !== 0n)
  6988.       writer.tag(4, WireType.Bit64).fixed64(message.version);
  6989.     let u = options.writeUnknownFields;
  6990.     if (u !== false)
  6991.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  6992.     return writer;
  6993.   }
  6994. }
  6995. var ApplicationUserRoleConnection = new ApplicationUserRoleConnection$Type;
  6996. // node_modules/discord-protos/src/discord_protos/discord_kkv_store_value_models/v1/AcknowledgedApplicationDisclosures.ts
  6997. var AcknowledgedApplicationDisclosures_ApplicationDisclosureType;
  6998. ((AcknowledgedApplicationDisclosures_ApplicationDisclosureType2) => {
  6999.   AcknowledgedApplicationDisclosures_ApplicationDisclosureType2[AcknowledgedApplicationDisclosures_ApplicationDisclosureType2["UNSPECIFIED_DISCLOSURE"] = 0] = "UNSPECIFIED_DISCLOSURE";
  7000.   AcknowledgedApplicationDisclosures_ApplicationDisclosureType2[AcknowledgedApplicationDisclosures_ApplicationDisclosureType2["IP_LOCATION"] = 1] = "IP_LOCATION";
  7001.   AcknowledgedApplicationDisclosures_ApplicationDisclosureType2[AcknowledgedApplicationDisclosures_ApplicationDisclosureType2["DISPLAYS_ADVERTISEMENTS"] = 2] = "DISPLAYS_ADVERTISEMENTS";
  7002.   AcknowledgedApplicationDisclosures_ApplicationDisclosureType2[AcknowledgedApplicationDisclosures_ApplicationDisclosureType2["PARTNER_SDK_DATA_SHARING_MESSAGE"] = 3] = "PARTNER_SDK_DATA_SHARING_MESSAGE";
  7003. })(AcknowledgedApplicationDisclosures_ApplicationDisclosureType ||= {});
  7004.  
  7005. class AcknowledgedApplicationDisclosures$Type extends MessageType {
  7006.   constructor() {
  7007.     super("discord_protos.discord_kkv_store_value_models.v1.AcknowledgedApplicationDisclosures", [
  7008.       { no: 1, name: "acked_disclosures", kind: "message", repeat: 1, T: () => AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure }
  7009.     ]);
  7010.   }
  7011.   create(value) {
  7012.     const message = globalThis.Object.create(this.messagePrototype);
  7013.     message.ackedDisclosures = [];
  7014.     if (value !== undefined)
  7015.       reflectionMergePartial(this, message, value);
  7016.     return message;
  7017.   }
  7018.   internalBinaryRead(reader, length, options, target) {
  7019.     let message = target ?? this.create(), end = reader.pos + length;
  7020.     while (reader.pos < end) {
  7021.       let [fieldNo, wireType] = reader.tag();
  7022.       switch (fieldNo) {
  7023.         case 1:
  7024.           message.ackedDisclosures.push(AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure.internalBinaryRead(reader, reader.uint32(), options));
  7025.           break;
  7026.         default:
  7027.           let u = options.readUnknownField;
  7028.           if (u === "throw")
  7029.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7030.           let d = reader.skip(wireType);
  7031.           if (u !== false)
  7032.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7033.       }
  7034.     }
  7035.     return message;
  7036.   }
  7037.   internalBinaryWrite(message, writer, options) {
  7038.     for (let i = 0;i < message.ackedDisclosures.length; i++)
  7039.       AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure.internalBinaryWrite(message.ackedDisclosures[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  7040.     let u = options.writeUnknownFields;
  7041.     if (u !== false)
  7042.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7043.     return writer;
  7044.   }
  7045. }
  7046. var AcknowledgedApplicationDisclosures = new AcknowledgedApplicationDisclosures$Type;
  7047.  
  7048. class AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure$Type extends MessageType {
  7049.   constructor() {
  7050.     super("discord_protos.discord_kkv_store_value_models.v1.AcknowledgedApplicationDisclosures.AcknowledgedApplicationDisclosure", [
  7051.       { no: 1, name: "disclosure_type", kind: "enum", T: () => ["discord_protos.discord_kkv_store_value_models.v1.AcknowledgedApplicationDisclosures.ApplicationDisclosureType", AcknowledgedApplicationDisclosures_ApplicationDisclosureType, "APPLICATION_DISCLOSURE_TYPE_"] },
  7052.       { no: 2, name: "acked_at", kind: "message", T: () => Timestamp }
  7053.     ]);
  7054.   }
  7055.   create(value) {
  7056.     const message = globalThis.Object.create(this.messagePrototype);
  7057.     message.disclosureType = 0;
  7058.     if (value !== undefined)
  7059.       reflectionMergePartial(this, message, value);
  7060.     return message;
  7061.   }
  7062.   internalBinaryRead(reader, length, options, target) {
  7063.     let message = target ?? this.create(), end = reader.pos + length;
  7064.     while (reader.pos < end) {
  7065.       let [fieldNo, wireType] = reader.tag();
  7066.       switch (fieldNo) {
  7067.         case 1:
  7068.           message.disclosureType = reader.int32();
  7069.           break;
  7070.         case 2:
  7071.           message.ackedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.ackedAt);
  7072.           break;
  7073.         default:
  7074.           let u = options.readUnknownField;
  7075.           if (u === "throw")
  7076.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7077.           let d = reader.skip(wireType);
  7078.           if (u !== false)
  7079.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7080.       }
  7081.     }
  7082.     return message;
  7083.   }
  7084.   internalBinaryWrite(message, writer, options) {
  7085.     if (message.disclosureType !== 0)
  7086.       writer.tag(1, WireType.Varint).int32(message.disclosureType);
  7087.     if (message.ackedAt)
  7088.       Timestamp.internalBinaryWrite(message.ackedAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  7089.     let u = options.writeUnknownFields;
  7090.     if (u !== false)
  7091.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7092.     return writer;
  7093.   }
  7094. }
  7095. var AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure = new AcknowledgedApplicationDisclosures_AcknowledgedApplicationDisclosure$Type;
  7096. // node_modules/discord-protos/src/discord_protos/premium_marketing/v1/PremiumMarketingComponentProperties.ts
  7097. var PremiumMarketingComponentProperties_ButtonAction;
  7098. ((PremiumMarketingComponentProperties_ButtonAction2) => {
  7099.   PremiumMarketingComponentProperties_ButtonAction2[PremiumMarketingComponentProperties_ButtonAction2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
  7100.   PremiumMarketingComponentProperties_ButtonAction2[PremiumMarketingComponentProperties_ButtonAction2["OPEN_MARKETING_PAGE"] = 1] = "OPEN_MARKETING_PAGE";
  7101.   PremiumMarketingComponentProperties_ButtonAction2[PremiumMarketingComponentProperties_ButtonAction2["OPEN_TIER_2_PAYMENT_MODAL"] = 2] = "OPEN_TIER_2_PAYMENT_MODAL";
  7102.   PremiumMarketingComponentProperties_ButtonAction2[PremiumMarketingComponentProperties_ButtonAction2["OPEN_TIER_1_PAYMENT_MODAL"] = 3] = "OPEN_TIER_1_PAYMENT_MODAL";
  7103.   PremiumMarketingComponentProperties_ButtonAction2[PremiumMarketingComponentProperties_ButtonAction2["OPEN_TIER_2_PAYMENT_MODAL_CUSTOM_CONFIRMATION_FOOTER"] = 4] = "OPEN_TIER_2_PAYMENT_MODAL_CUSTOM_CONFIRMATION_FOOTER";
  7104. })(PremiumMarketingComponentProperties_ButtonAction ||= {});
  7105.  
  7106. class PremiumMarketingComponentProperties$Type extends MessageType {
  7107.   constructor() {
  7108.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties", [
  7109.       { no: 3, name: "content_identifier", kind: "scalar", T: 9 },
  7110.       { no: 1, name: "placeholder", kind: "scalar", oneof: "properties", T: 9 },
  7111.       { no: 2, name: "announcement_modal_variant_1", kind: "message", oneof: "properties", T: () => PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties }
  7112.     ]);
  7113.   }
  7114.   create(value) {
  7115.     const message = globalThis.Object.create(this.messagePrototype);
  7116.     message.contentIdentifier = "";
  7117.     message.properties = { oneofKind: undefined };
  7118.     if (value !== undefined)
  7119.       reflectionMergePartial(this, message, value);
  7120.     return message;
  7121.   }
  7122.   internalBinaryRead(reader, length, options, target) {
  7123.     let message = target ?? this.create(), end = reader.pos + length;
  7124.     while (reader.pos < end) {
  7125.       let [fieldNo, wireType] = reader.tag();
  7126.       switch (fieldNo) {
  7127.         case 3:
  7128.           message.contentIdentifier = reader.string();
  7129.           break;
  7130.         case 1:
  7131.           message.properties = {
  7132.             oneofKind: "placeholder",
  7133.             placeholder: reader.string()
  7134.           };
  7135.           break;
  7136.         case 2:
  7137.           message.properties = {
  7138.             oneofKind: "announcementModalVariant1",
  7139.             announcementModalVariant1: PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties.internalBinaryRead(reader, reader.uint32(), options, message.properties.announcementModalVariant1)
  7140.           };
  7141.           break;
  7142.         default:
  7143.           let u = options.readUnknownField;
  7144.           if (u === "throw")
  7145.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7146.           let d = reader.skip(wireType);
  7147.           if (u !== false)
  7148.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7149.       }
  7150.     }
  7151.     return message;
  7152.   }
  7153.   internalBinaryWrite(message, writer, options) {
  7154.     if (message.contentIdentifier !== "")
  7155.       writer.tag(3, WireType.LengthDelimited).string(message.contentIdentifier);
  7156.     if (message.properties.oneofKind === "placeholder")
  7157.       writer.tag(1, WireType.LengthDelimited).string(message.properties.placeholder);
  7158.     if (message.properties.oneofKind === "announcementModalVariant1")
  7159.       PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties.internalBinaryWrite(message.properties.announcementModalVariant1, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  7160.     let u = options.writeUnknownFields;
  7161.     if (u !== false)
  7162.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7163.     return writer;
  7164.   }
  7165. }
  7166. var PremiumMarketingComponentProperties = new PremiumMarketingComponentProperties$Type;
  7167.  
  7168. class PremiumMarketingComponentProperties_FeatureCard$Type extends MessageType {
  7169.   constructor() {
  7170.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.FeatureCard", [
  7171.       { no: 1, name: "header", kind: "scalar", T: 9 },
  7172.       { no: 2, name: "pill", kind: "scalar", T: 9 },
  7173.       { no: 3, name: "body", kind: "scalar", T: 9 },
  7174.       { no: 4, name: "image_link", kind: "scalar", T: 9 },
  7175.       { no: 5, name: "image_link_light_theme", kind: "scalar", T: 9 }
  7176.     ]);
  7177.   }
  7178.   create(value) {
  7179.     const message = globalThis.Object.create(this.messagePrototype);
  7180.     message.header = "";
  7181.     message.pill = "";
  7182.     message.body = "";
  7183.     message.imageLink = "";
  7184.     message.imageLinkLightTheme = "";
  7185.     if (value !== undefined)
  7186.       reflectionMergePartial(this, message, value);
  7187.     return message;
  7188.   }
  7189.   internalBinaryRead(reader, length, options, target) {
  7190.     let message = target ?? this.create(), end = reader.pos + length;
  7191.     while (reader.pos < end) {
  7192.       let [fieldNo, wireType] = reader.tag();
  7193.       switch (fieldNo) {
  7194.         case 1:
  7195.           message.header = reader.string();
  7196.           break;
  7197.         case 2:
  7198.           message.pill = reader.string();
  7199.           break;
  7200.         case 3:
  7201.           message.body = reader.string();
  7202.           break;
  7203.         case 4:
  7204.           message.imageLink = reader.string();
  7205.           break;
  7206.         case 5:
  7207.           message.imageLinkLightTheme = reader.string();
  7208.           break;
  7209.         default:
  7210.           let u = options.readUnknownField;
  7211.           if (u === "throw")
  7212.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7213.           let d = reader.skip(wireType);
  7214.           if (u !== false)
  7215.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7216.       }
  7217.     }
  7218.     return message;
  7219.   }
  7220.   internalBinaryWrite(message, writer, options) {
  7221.     if (message.header !== "")
  7222.       writer.tag(1, WireType.LengthDelimited).string(message.header);
  7223.     if (message.pill !== "")
  7224.       writer.tag(2, WireType.LengthDelimited).string(message.pill);
  7225.     if (message.body !== "")
  7226.       writer.tag(3, WireType.LengthDelimited).string(message.body);
  7227.     if (message.imageLink !== "")
  7228.       writer.tag(4, WireType.LengthDelimited).string(message.imageLink);
  7229.     if (message.imageLinkLightTheme !== "")
  7230.       writer.tag(5, WireType.LengthDelimited).string(message.imageLinkLightTheme);
  7231.     let u = options.writeUnknownFields;
  7232.     if (u !== false)
  7233.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7234.     return writer;
  7235.   }
  7236. }
  7237. var PremiumMarketingComponentProperties_FeatureCard = new PremiumMarketingComponentProperties_FeatureCard$Type;
  7238.  
  7239. class PremiumMarketingComponentProperties_SubscriptionButton$Type extends MessageType {
  7240.   constructor() {
  7241.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.SubscriptionButton", [
  7242.       { no: 1, name: "copy", kind: "scalar", T: 9 },
  7243.       { no: 2, name: "button_action", kind: "enum", T: () => ["discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.ButtonAction", PremiumMarketingComponentProperties_ButtonAction, "BUTTON_ACTION_"] }
  7244.     ]);
  7245.   }
  7246.   create(value) {
  7247.     const message = globalThis.Object.create(this.messagePrototype);
  7248.     message.copy = "";
  7249.     message.buttonAction = 0;
  7250.     if (value !== undefined)
  7251.       reflectionMergePartial(this, message, value);
  7252.     return message;
  7253.   }
  7254.   internalBinaryRead(reader, length, options, target) {
  7255.     let message = target ?? this.create(), end = reader.pos + length;
  7256.     while (reader.pos < end) {
  7257.       let [fieldNo, wireType] = reader.tag();
  7258.       switch (fieldNo) {
  7259.         case 1:
  7260.           message.copy = reader.string();
  7261.           break;
  7262.         case 2:
  7263.           message.buttonAction = reader.int32();
  7264.           break;
  7265.         default:
  7266.           let u = options.readUnknownField;
  7267.           if (u === "throw")
  7268.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7269.           let d = reader.skip(wireType);
  7270.           if (u !== false)
  7271.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7272.       }
  7273.     }
  7274.     return message;
  7275.   }
  7276.   internalBinaryWrite(message, writer, options) {
  7277.     if (message.copy !== "")
  7278.       writer.tag(1, WireType.LengthDelimited).string(message.copy);
  7279.     if (message.buttonAction !== 0)
  7280.       writer.tag(2, WireType.Varint).int32(message.buttonAction);
  7281.     let u = options.writeUnknownFields;
  7282.     if (u !== false)
  7283.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7284.     return writer;
  7285.   }
  7286. }
  7287. var PremiumMarketingComponentProperties_SubscriptionButton = new PremiumMarketingComponentProperties_SubscriptionButton$Type;
  7288.  
  7289. class PremiumMarketingComponentProperties_Subtitle$Type extends MessageType {
  7290.   constructor() {
  7291.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.Subtitle", [
  7292.       { no: 1, name: "link", kind: "scalar", T: 9 },
  7293.       { no: 2, name: "locale", kind: "scalar", T: 9 },
  7294.       { no: 3, name: "is_default", kind: "scalar", T: 8 }
  7295.     ]);
  7296.   }
  7297.   create(value) {
  7298.     const message = globalThis.Object.create(this.messagePrototype);
  7299.     message.link = "";
  7300.     message.locale = "";
  7301.     message.isDefault = false;
  7302.     if (value !== undefined)
  7303.       reflectionMergePartial(this, message, value);
  7304.     return message;
  7305.   }
  7306.   internalBinaryRead(reader, length, options, target) {
  7307.     let message = target ?? this.create(), end = reader.pos + length;
  7308.     while (reader.pos < end) {
  7309.       let [fieldNo, wireType] = reader.tag();
  7310.       switch (fieldNo) {
  7311.         case 1:
  7312.           message.link = reader.string();
  7313.           break;
  7314.         case 2:
  7315.           message.locale = reader.string();
  7316.           break;
  7317.         case 3:
  7318.           message.isDefault = reader.bool();
  7319.           break;
  7320.         default:
  7321.           let u = options.readUnknownField;
  7322.           if (u === "throw")
  7323.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7324.           let d = reader.skip(wireType);
  7325.           if (u !== false)
  7326.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7327.       }
  7328.     }
  7329.     return message;
  7330.   }
  7331.   internalBinaryWrite(message, writer, options) {
  7332.     if (message.link !== "")
  7333.       writer.tag(1, WireType.LengthDelimited).string(message.link);
  7334.     if (message.locale !== "")
  7335.       writer.tag(2, WireType.LengthDelimited).string(message.locale);
  7336.     if (message.isDefault !== false)
  7337.       writer.tag(3, WireType.Varint).bool(message.isDefault);
  7338.     let u = options.writeUnknownFields;
  7339.     if (u !== false)
  7340.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7341.     return writer;
  7342.   }
  7343. }
  7344. var PremiumMarketingComponentProperties_Subtitle = new PremiumMarketingComponentProperties_Subtitle$Type;
  7345.  
  7346. class PremiumMarketingComponentProperties_Variant1Storage$Type extends MessageType {
  7347.   constructor() {
  7348.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.Variant1Storage", [
  7349.       { no: 1, name: "hero_art_localized_video_links_dark_theme", kind: "map", K: 9, V: { kind: "scalar", T: 9 } },
  7350.       { no: 2, name: "hero_art_localized_video_links_light_theme", kind: "map", K: 9, V: { kind: "scalar", T: 9 } },
  7351.       { no: 3, name: "hero_art_video_subtitle_links", kind: "map", K: 9, V: { kind: "scalar", T: 9 } }
  7352.     ]);
  7353.   }
  7354.   create(value) {
  7355.     const message = globalThis.Object.create(this.messagePrototype);
  7356.     message.heroArtLocalizedVideoLinksDarkTheme = {};
  7357.     message.heroArtLocalizedVideoLinksLightTheme = {};
  7358.     message.heroArtVideoSubtitleLinks = {};
  7359.     if (value !== undefined)
  7360.       reflectionMergePartial(this, message, value);
  7361.     return message;
  7362.   }
  7363.   internalBinaryRead(reader, length, options, target) {
  7364.     let message = target ?? this.create(), end = reader.pos + length;
  7365.     while (reader.pos < end) {
  7366.       let [fieldNo, wireType] = reader.tag();
  7367.       switch (fieldNo) {
  7368.         case 1:
  7369.           this.binaryReadMap1(message.heroArtLocalizedVideoLinksDarkTheme, reader, options);
  7370.           break;
  7371.         case 2:
  7372.           this.binaryReadMap2(message.heroArtLocalizedVideoLinksLightTheme, reader, options);
  7373.           break;
  7374.         case 3:
  7375.           this.binaryReadMap3(message.heroArtVideoSubtitleLinks, reader, options);
  7376.           break;
  7377.         default:
  7378.           let u = options.readUnknownField;
  7379.           if (u === "throw")
  7380.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7381.           let d = reader.skip(wireType);
  7382.           if (u !== false)
  7383.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7384.       }
  7385.     }
  7386.     return message;
  7387.   }
  7388.   binaryReadMap1(map, reader, options) {
  7389.     let len = reader.uint32(), end = reader.pos + len, key, val;
  7390.     while (reader.pos < end) {
  7391.       let [fieldNo, wireType] = reader.tag();
  7392.       switch (fieldNo) {
  7393.         case 1:
  7394.           key = reader.string();
  7395.           break;
  7396.         case 2:
  7397.           val = reader.string();
  7398.           break;
  7399.         default:
  7400.           throw new globalThis.Error("unknown map entry field for field discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.Variant1Storage.hero_art_localized_video_links_dark_theme");
  7401.       }
  7402.     }
  7403.     map[key ?? ""] = val ?? "";
  7404.   }
  7405.   binaryReadMap2(map, reader, options) {
  7406.     let len = reader.uint32(), end = reader.pos + len, key, val;
  7407.     while (reader.pos < end) {
  7408.       let [fieldNo, wireType] = reader.tag();
  7409.       switch (fieldNo) {
  7410.         case 1:
  7411.           key = reader.string();
  7412.           break;
  7413.         case 2:
  7414.           val = reader.string();
  7415.           break;
  7416.         default:
  7417.           throw new globalThis.Error("unknown map entry field for field discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.Variant1Storage.hero_art_localized_video_links_light_theme");
  7418.       }
  7419.     }
  7420.     map[key ?? ""] = val ?? "";
  7421.   }
  7422.   binaryReadMap3(map, reader, options) {
  7423.     let len = reader.uint32(), end = reader.pos + len, key, val;
  7424.     while (reader.pos < end) {
  7425.       let [fieldNo, wireType] = reader.tag();
  7426.       switch (fieldNo) {
  7427.         case 1:
  7428.           key = reader.string();
  7429.           break;
  7430.         case 2:
  7431.           val = reader.string();
  7432.           break;
  7433.         default:
  7434.           throw new globalThis.Error("unknown map entry field for field discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.Variant1Storage.hero_art_video_subtitle_links");
  7435.       }
  7436.     }
  7437.     map[key ?? ""] = val ?? "";
  7438.   }
  7439.   internalBinaryWrite(message, writer, options) {
  7440.     for (let k of globalThis.Object.keys(message.heroArtLocalizedVideoLinksDarkTheme))
  7441.       writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.heroArtLocalizedVideoLinksDarkTheme[k]).join();
  7442.     for (let k of globalThis.Object.keys(message.heroArtLocalizedVideoLinksLightTheme))
  7443.       writer.tag(2, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.heroArtLocalizedVideoLinksLightTheme[k]).join();
  7444.     for (let k of globalThis.Object.keys(message.heroArtVideoSubtitleLinks))
  7445.       writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.heroArtVideoSubtitleLinks[k]).join();
  7446.     let u = options.writeUnknownFields;
  7447.     if (u !== false)
  7448.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7449.     return writer;
  7450.   }
  7451. }
  7452. var PremiumMarketingComponentProperties_Variant1Storage = new PremiumMarketingComponentProperties_Variant1Storage$Type;
  7453.  
  7454. class PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties$Type extends MessageType {
  7455.   constructor() {
  7456.     super("discord_protos.premium_marketing.v1.PremiumMarketingComponentProperties.AnnouncementModalVariant1Properties", [
  7457.       { no: 1, name: "header", kind: "scalar", T: 9 },
  7458.       { no: 2, name: "subheader", kind: "scalar", T: 9 },
  7459.       { no: 3, name: "video_link", kind: "scalar", T: 9 },
  7460.       { no: 4, name: "help_article_id", kind: "scalar", T: 9 },
  7461.       { no: 5, name: "feature_cards", kind: "message", repeat: 1, T: () => PremiumMarketingComponentProperties_FeatureCard },
  7462.       { no: 6, name: "button", kind: "message", T: () => PremiumMarketingComponentProperties_SubscriptionButton },
  7463.       { no: 7, name: "dismiss_key", kind: "scalar", T: 9 },
  7464.       { no: 8, name: "hero_art_video_link_light_theme", kind: "scalar", T: 9 },
  7465.       { no: 9, name: "hero_art_image_link_dark_theme", kind: "scalar", T: 9 },
  7466.       { no: 10, name: "hero_art_image_link_light_theme", kind: "scalar", T: 9 },
  7467.       { no: 11, name: "modal_top_pill", kind: "scalar", T: 9 },
  7468.       { no: 12, name: "body", kind: "scalar", T: 9 },
  7469.       { no: 13, name: "hero_art_video_subtitles", kind: "message", repeat: 1, T: () => PremiumMarketingComponentProperties_Subtitle },
  7470.       { no: 14, name: "storage", kind: "message", T: () => PremiumMarketingComponentProperties_Variant1Storage }
  7471.     ]);
  7472.   }
  7473.   create(value) {
  7474.     const message = globalThis.Object.create(this.messagePrototype);
  7475.     message.header = "";
  7476.     message.subheader = "";
  7477.     message.videoLink = "";
  7478.     message.helpArticleId = "";
  7479.     message.featureCards = [];
  7480.     message.dismissKey = "";
  7481.     message.heroArtVideoLinkLightTheme = "";
  7482.     message.heroArtImageLinkDarkTheme = "";
  7483.     message.heroArtImageLinkLightTheme = "";
  7484.     message.modalTopPill = "";
  7485.     message.body = "";
  7486.     message.heroArtVideoSubtitles = [];
  7487.     if (value !== undefined)
  7488.       reflectionMergePartial(this, message, value);
  7489.     return message;
  7490.   }
  7491.   internalBinaryRead(reader, length, options, target) {
  7492.     let message = target ?? this.create(), end = reader.pos + length;
  7493.     while (reader.pos < end) {
  7494.       let [fieldNo, wireType] = reader.tag();
  7495.       switch (fieldNo) {
  7496.         case 1:
  7497.           message.header = reader.string();
  7498.           break;
  7499.         case 2:
  7500.           message.subheader = reader.string();
  7501.           break;
  7502.         case 3:
  7503.           message.videoLink = reader.string();
  7504.           break;
  7505.         case 4:
  7506.           message.helpArticleId = reader.string();
  7507.           break;
  7508.         case 5:
  7509.           message.featureCards.push(PremiumMarketingComponentProperties_FeatureCard.internalBinaryRead(reader, reader.uint32(), options));
  7510.           break;
  7511.         case 6:
  7512.           message.button = PremiumMarketingComponentProperties_SubscriptionButton.internalBinaryRead(reader, reader.uint32(), options, message.button);
  7513.           break;
  7514.         case 7:
  7515.           message.dismissKey = reader.string();
  7516.           break;
  7517.         case 8:
  7518.           message.heroArtVideoLinkLightTheme = reader.string();
  7519.           break;
  7520.         case 9:
  7521.           message.heroArtImageLinkDarkTheme = reader.string();
  7522.           break;
  7523.         case 10:
  7524.           message.heroArtImageLinkLightTheme = reader.string();
  7525.           break;
  7526.         case 11:
  7527.           message.modalTopPill = reader.string();
  7528.           break;
  7529.         case 12:
  7530.           message.body = reader.string();
  7531.           break;
  7532.         case 13:
  7533.           message.heroArtVideoSubtitles.push(PremiumMarketingComponentProperties_Subtitle.internalBinaryRead(reader, reader.uint32(), options));
  7534.           break;
  7535.         case 14:
  7536.           message.storage = PremiumMarketingComponentProperties_Variant1Storage.internalBinaryRead(reader, reader.uint32(), options, message.storage);
  7537.           break;
  7538.         default:
  7539.           let u = options.readUnknownField;
  7540.           if (u === "throw")
  7541.             throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  7542.           let d = reader.skip(wireType);
  7543.           if (u !== false)
  7544.             (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  7545.       }
  7546.     }
  7547.     return message;
  7548.   }
  7549.   internalBinaryWrite(message, writer, options) {
  7550.     if (message.header !== "")
  7551.       writer.tag(1, WireType.LengthDelimited).string(message.header);
  7552.     if (message.subheader !== "")
  7553.       writer.tag(2, WireType.LengthDelimited).string(message.subheader);
  7554.     if (message.videoLink !== "")
  7555.       writer.tag(3, WireType.LengthDelimited).string(message.videoLink);
  7556.     if (message.helpArticleId !== "")
  7557.       writer.tag(4, WireType.LengthDelimited).string(message.helpArticleId);
  7558.     for (let i = 0;i < message.featureCards.length; i++)
  7559.       PremiumMarketingComponentProperties_FeatureCard.internalBinaryWrite(message.featureCards[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
  7560.     if (message.button)
  7561.       PremiumMarketingComponentProperties_SubscriptionButton.internalBinaryWrite(message.button, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
  7562.     if (message.dismissKey !== "")
  7563.       writer.tag(7, WireType.LengthDelimited).string(message.dismissKey);
  7564.     if (message.heroArtVideoLinkLightTheme !== "")
  7565.       writer.tag(8, WireType.LengthDelimited).string(message.heroArtVideoLinkLightTheme);
  7566.     if (message.heroArtImageLinkDarkTheme !== "")
  7567.       writer.tag(9, WireType.LengthDelimited).string(message.heroArtImageLinkDarkTheme);
  7568.     if (message.heroArtImageLinkLightTheme !== "")
  7569.       writer.tag(10, WireType.LengthDelimited).string(message.heroArtImageLinkLightTheme);
  7570.     if (message.modalTopPill !== "")
  7571.       writer.tag(11, WireType.LengthDelimited).string(message.modalTopPill);
  7572.     if (message.body !== "")
  7573.       writer.tag(12, WireType.LengthDelimited).string(message.body);
  7574.     for (let i = 0;i < message.heroArtVideoSubtitles.length; i++)
  7575.       PremiumMarketingComponentProperties_Subtitle.internalBinaryWrite(message.heroArtVideoSubtitles[i], writer.tag(13, WireType.LengthDelimited).fork(), options).join();
  7576.     if (message.storage)
  7577.       PremiumMarketingComponentProperties_Variant1Storage.internalBinaryWrite(message.storage, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
  7578.     let u = options.writeUnknownFields;
  7579.     if (u !== false)
  7580.       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  7581.     return writer;
  7582.   }
  7583. }
  7584. var PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties = new PremiumMarketingComponentProperties_AnnouncementModalVariant1Properties$Type;
  7585.  
  7586. // node_modules/discord-protos/src/index.ts
  7587. var compatBuffer = {
  7588.   from: function(input, encoding) {
  7589.     if (typeof input === "string" && encoding === "base64") {
  7590.       const encodedBytes = atob(input);
  7591.       const bytes = new Uint8Array(encodedBytes.length);
  7592.       for (let i = 0;i < encodedBytes.length; i++) {
  7593.         bytes[i] = encodedBytes.charCodeAt(i);
  7594.       }
  7595.       return bytes;
  7596.     } else if (!encoding && input instanceof Uint8Array) {
  7597.       return input;
  7598.     }
  7599.     throw new Error("Invalid input type.");
  7600.   },
  7601.   toBase64String: function(buffer) {
  7602.     let encodedBytes = "";
  7603.     for (let i = 0;i < buffer.length; i++) {
  7604.       encodedBytes += String.fromCharCode(buffer[i]);
  7605.     }
  7606.     return btoa(encodedBytes);
  7607.   }
  7608. };
  7609. function toBase64(data) {
  7610.   return compatBuffer.toBase64String(compatBuffer.from(this.toBinary(data)));
  7611. }
  7612. function fromBase64(base64) {
  7613.   return this.fromBinary(compatBuffer.from(base64, "base64"));
  7614. }
  7615. MessageType.prototype.fromBase64 = fromBase64;
  7616. MessageType.prototype.toBase64 = toBase64;
  7617.  
  7618. // index.js
  7619. GM_addStyle(`
  7620.   #status-selector {
  7621.     position: fixed;
  7622.     bottom: 20px;
  7623.     left: 20px;
  7624.     background-color: rgba(0, 0, 0, 0.7);
  7625.     color: white;
  7626.     padding: 10px;
  7627.     border-radius: 5px;
  7628.     display: flex;
  7629.     flex-direction: column;
  7630.     gap: 5px;
  7631.     z-index: 9999;
  7632.   }
  7633.   #status-selector button {
  7634.     background: none;
  7635.     border: 1px solid white;
  7636.     color: white;
  7637.     padding: 8px;
  7638.     cursor: pointer;
  7639.   }
  7640.   #status-selector button.online {
  7641.     background-color: #43a25a;
  7642.   }
  7643.   #status-selector button.idle {
  7644.     background-color: #ca9654;
  7645.   }
  7646.   #status-selector button.dnd {
  7647.     background-color: #d83a42;
  7648.   }
  7649.   #status-selector button.invisible {
  7650.     background-color: #83838b;
  7651.   }
  7652. `);
  7653. (async () => {
  7654.  
  7655.   class StatusMenu {
  7656.     constructor(discordToken) {
  7657.       this.discordToken = discordToken;
  7658.       this.statusSelector = null;
  7659.       this.buttons = {};
  7660.     }
  7661.     async init() {
  7662.       this.statusSelector = document.createElement("div");
  7663.       this.statusSelector.id = "status-selector";
  7664.       document.body.appendChild(this.statusSelector);
  7665.       const currentStatus = (await this.fetchCurrentUserSettings()).status.status.value;
  7666.       ["online", "idle", "dnd", "invisible"].forEach((status) => {
  7667.         const button = document.createElement("button");
  7668.         button.textContent = status.charAt(0).toUpperCase() + status.slice(1);
  7669.         button.classList.toggle(status, status === currentStatus);
  7670.         button.onclick = async () => {
  7671.           const newUserSettings = await this.fetchCurrentUserSettings();
  7672.           newUserSettings.status.status.value = status;
  7673.           await this.setUserSettings(newUserSettings);
  7674.           await this.refreshStatus(status);
  7675.         };
  7676.         this.statusSelector.appendChild(button);
  7677.         this.buttons[status] = button;
  7678.       });
  7679.     }
  7680.     async refreshStatus(currentStatus = null) {
  7681.       if (!currentStatus) {
  7682.         currentStatus = (await this.fetchCurrentUserSettings()).status.status.value;
  7683.       }
  7684.       for (const [status, button] of Object.entries(this.buttons)) {
  7685.         button.classList.toggle(status, status === currentStatus);
  7686.       }
  7687.     }
  7688.     async fetchCurrentUserSettings() {
  7689.       const response = await fetch("https://discord.com/api/v9/users/@me/settings-proto/1", {
  7690.         headers: {
  7691.           Authorization: this.discordToken
  7692.         }
  7693.       });
  7694.       const data = await response.json();
  7695.       const decoded = PreloadedUserSettings.fromBase64(data.settings);
  7696.       return decoded;
  7697.     }
  7698.     async setUserSettings(userSettings) {
  7699.       const encoded = PreloadedUserSettings.toBase64(userSettings);
  7700.       await fetch("https://discord.com/api/v9/users/@me/settings-proto/1", {
  7701.         method: "PATCH",
  7702.         headers: {
  7703.           "Content-Type": "application/json",
  7704.           Authorization: this.discordToken
  7705.         },
  7706.         body: JSON.stringify({ settings: encoded })
  7707.       });
  7708.     }
  7709.   }
  7710.   const token = JSON.parse(window.localStorage.getItem("token"));
  7711.   if (!token) {
  7712.     console.warn("You need to be signed in to Discord to change your status.");
  7713.     return;
  7714.   }
  7715.   await new Promise((resolve) => {
  7716.     if (document.readyState === "complete") {
  7717.       resolve();
  7718.     } else {
  7719.       window.addEventListener("load", resolve);
  7720.     }
  7721.   });
  7722.   const menu = new StatusMenu(token);
  7723.   await menu.init();
  7724. })();