cs2-protobuf 1.0.1

package/.dist/generated/source2_steam_stats.js

@@ -0,0 +1,2070 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: source2_steam_stats.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export var ESource2PlayStatsFieldType;
+(function (ESource2PlayStatsFieldType) {
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Invalid"] = 0] = "Source2PlayStats_Invalid";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_UInt64"] = 1] = "Source2PlayStats_UInt64";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_UInt32"] = 2] = "Source2PlayStats_UInt32";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_UInt16"] = 3] = "Source2PlayStats_UInt16";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_UInt8"] = 4] = "Source2PlayStats_UInt8";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Int64"] = 5] = "Source2PlayStats_Int64";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Int32"] = 6] = "Source2PlayStats_Int32";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Int16"] = 7] = "Source2PlayStats_Int16";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Int8"] = 8] = "Source2PlayStats_Int8";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Float64"] = 9] = "Source2PlayStats_Float64";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Float32"] = 10] = "Source2PlayStats_Float32";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_Bool"] = 11] = "Source2PlayStats_Bool";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_String"] = 12] = "Source2PlayStats_String";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_LowCardinalityString"] = 13] = "Source2PlayStats_LowCardinalityString";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_UTCDateTime"] = 14] = "Source2PlayStats_UTCDateTime";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_SteamIDTrustBucket"] = 15] = "Source2PlayStats_SteamIDTrustBucket";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_SteamIDTrustBucketMin"] = 16] = "Source2PlayStats_SteamIDTrustBucketMin";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["Source2PlayStats_SteamID"] = 17] = "Source2PlayStats_SteamID";
+    ESource2PlayStatsFieldType[ESource2PlayStatsFieldType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ESource2PlayStatsFieldType || (ESource2PlayStatsFieldType = {}));
+function createBaseCMsgSource2SystemSpecs() {
+    return {
+        cpuId: "",
+        cpuBrand: "",
+        cpuModel: 0,
+        cpuNumPhysical: 0,
+        ramPhysicalTotalMb: 0,
+        gpuRendersystemDllName: "",
+        gpuVendorId: 0,
+        gpuDriverName: "",
+        gpuDriverVersionHigh: 0,
+        gpuDriverVersionLow: 0,
+        gpuDxSupportLevel: 0,
+        gpuTextureMemorySizeMb: 0,
+        backbufferWidth: 0,
+        backbufferHeight: 0,
+    };
+}
+export const CMsgSource2SystemSpecs = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.cpuId !== undefined && message.cpuId !== "") {
+            writer.uint32(10).string(message.cpuId);
+        }
+        if (message.cpuBrand !== undefined && message.cpuBrand !== "") {
+            writer.uint32(18).string(message.cpuBrand);
+        }
+        if (message.cpuModel !== undefined && message.cpuModel !== 0) {
+            writer.uint32(24).uint32(message.cpuModel);
+        }
+        if (message.cpuNumPhysical !== undefined && message.cpuNumPhysical !== 0) {
+            writer.uint32(32).uint32(message.cpuNumPhysical);
+        }
+        if (message.ramPhysicalTotalMb !== undefined && message.ramPhysicalTotalMb !== 0) {
+            writer.uint32(168).uint32(message.ramPhysicalTotalMb);
+        }
+        if (message.gpuRendersystemDllName !== undefined && message.gpuRendersystemDllName !== "") {
+            writer.uint32(330).string(message.gpuRendersystemDllName);
+        }
+        if (message.gpuVendorId !== undefined && message.gpuVendorId !== 0) {
+            writer.uint32(336).uint32(message.gpuVendorId);
+        }
+        if (message.gpuDriverName !== undefined && message.gpuDriverName !== "") {
+            writer.uint32(346).string(message.gpuDriverName);
+        }
+        if (message.gpuDriverVersionHigh !== undefined && message.gpuDriverVersionHigh !== 0) {
+            writer.uint32(352).uint32(message.gpuDriverVersionHigh);
+        }
+        if (message.gpuDriverVersionLow !== undefined && message.gpuDriverVersionLow !== 0) {
+            writer.uint32(360).uint32(message.gpuDriverVersionLow);
+        }
+        if (message.gpuDxSupportLevel !== undefined && message.gpuDxSupportLevel !== 0) {
+            writer.uint32(368).uint32(message.gpuDxSupportLevel);
+        }
+        if (message.gpuTextureMemorySizeMb !== undefined && message.gpuTextureMemorySizeMb !== 0) {
+            writer.uint32(376).uint32(message.gpuTextureMemorySizeMb);
+        }
+        if (message.backbufferWidth !== undefined && message.backbufferWidth !== 0) {
+            writer.uint32(408).uint32(message.backbufferWidth);
+        }
+        if (message.backbufferHeight !== undefined && message.backbufferHeight !== 0) {
+            writer.uint32(416).uint32(message.backbufferHeight);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2SystemSpecs();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.cpuId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.cpuBrand = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.cpuModel = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.cpuNumPhysical = reader.uint32();
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 168) {
+                        break;
+                    }
+                    message.ramPhysicalTotalMb = reader.uint32();
+                    continue;
+                }
+                case 41: {
+                    if (tag !== 330) {
+                        break;
+                    }
+                    message.gpuRendersystemDllName = reader.string();
+                    continue;
+                }
+                case 42: {
+                    if (tag !== 336) {
+                        break;
+                    }
+                    message.gpuVendorId = reader.uint32();
+                    continue;
+                }
+                case 43: {
+                    if (tag !== 346) {
+                        break;
+                    }
+                    message.gpuDriverName = reader.string();
+                    continue;
+                }
+                case 44: {
+                    if (tag !== 352) {
+                        break;
+                    }
+                    message.gpuDriverVersionHigh = reader.uint32();
+                    continue;
+                }
+                case 45: {
+                    if (tag !== 360) {
+                        break;
+                    }
+                    message.gpuDriverVersionLow = reader.uint32();
+                    continue;
+                }
+                case 46: {
+                    if (tag !== 368) {
+                        break;
+                    }
+                    message.gpuDxSupportLevel = reader.uint32();
+                    continue;
+                }
+                case 47: {
+                    if (tag !== 376) {
+                        break;
+                    }
+                    message.gpuTextureMemorySizeMb = reader.uint32();
+                    continue;
+                }
+                case 51: {
+                    if (tag !== 408) {
+                        break;
+                    }
+                    message.backbufferWidth = reader.uint32();
+                    continue;
+                }
+                case 52: {
+                    if (tag !== 416) {
+                        break;
+                    }
+                    message.backbufferHeight = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2VProfLiteReportItem() {
+    return {
+        name: "",
+        activeSamples: 0,
+        activeSamples1secmax: 0,
+        usecMax: 0,
+        usecAvgActive: 0,
+        usecP50Active: 0,
+        usecP99Active: 0,
+        usecAvgAll: 0,
+        usecP50All: 0,
+        usecP99All: 0,
+        usec1secmaxAvgActive: 0,
+        usec1secmaxP50Active: 0,
+        usec1secmaxP95Active: 0,
+        usec1secmaxP99Active: 0,
+        usec1secmaxAvgAll: 0,
+        usec1secmaxP50All: 0,
+        usec1secmaxP95All: 0,
+        usec1secmaxP99All: 0,
+    };
+}
+export const CMsgSource2VProfLiteReportItem = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== undefined && message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.activeSamples !== undefined && message.activeSamples !== 0) {
+            writer.uint32(16).uint32(message.activeSamples);
+        }
+        if (message.activeSamples1secmax !== undefined && message.activeSamples1secmax !== 0) {
+            writer.uint32(32).uint32(message.activeSamples1secmax);
+        }
+        if (message.usecMax !== undefined && message.usecMax !== 0) {
+            writer.uint32(24).uint32(message.usecMax);
+        }
+        if (message.usecAvgActive !== undefined && message.usecAvgActive !== 0) {
+            writer.uint32(88).uint32(message.usecAvgActive);
+        }
+        if (message.usecP50Active !== undefined && message.usecP50Active !== 0) {
+            writer.uint32(96).uint32(message.usecP50Active);
+        }
+        if (message.usecP99Active !== undefined && message.usecP99Active !== 0) {
+            writer.uint32(104).uint32(message.usecP99Active);
+        }
+        if (message.usecAvgAll !== undefined && message.usecAvgAll !== 0) {
+            writer.uint32(168).uint32(message.usecAvgAll);
+        }
+        if (message.usecP50All !== undefined && message.usecP50All !== 0) {
+            writer.uint32(176).uint32(message.usecP50All);
+        }
+        if (message.usecP99All !== undefined && message.usecP99All !== 0) {
+            writer.uint32(184).uint32(message.usecP99All);
+        }
+        if (message.usec1secmaxAvgActive !== undefined && message.usec1secmaxAvgActive !== 0) {
+            writer.uint32(248).uint32(message.usec1secmaxAvgActive);
+        }
+        if (message.usec1secmaxP50Active !== undefined && message.usec1secmaxP50Active !== 0) {
+            writer.uint32(256).uint32(message.usec1secmaxP50Active);
+        }
+        if (message.usec1secmaxP95Active !== undefined && message.usec1secmaxP95Active !== 0) {
+            writer.uint32(264).uint32(message.usec1secmaxP95Active);
+        }
+        if (message.usec1secmaxP99Active !== undefined && message.usec1secmaxP99Active !== 0) {
+            writer.uint32(272).uint32(message.usec1secmaxP99Active);
+        }
+        if (message.usec1secmaxAvgAll !== undefined && message.usec1secmaxAvgAll !== 0) {
+            writer.uint32(328).uint32(message.usec1secmaxAvgAll);
+        }
+        if (message.usec1secmaxP50All !== undefined && message.usec1secmaxP50All !== 0) {
+            writer.uint32(336).uint32(message.usec1secmaxP50All);
+        }
+        if (message.usec1secmaxP95All !== undefined && message.usec1secmaxP95All !== 0) {
+            writer.uint32(344).uint32(message.usec1secmaxP95All);
+        }
+        if (message.usec1secmaxP99All !== undefined && message.usec1secmaxP99All !== 0) {
+            writer.uint32(352).uint32(message.usec1secmaxP99All);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2VProfLiteReportItem();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.activeSamples = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.activeSamples1secmax = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.usecMax = reader.uint32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.usecAvgActive = reader.uint32();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.usecP50Active = reader.uint32();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.usecP99Active = reader.uint32();
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 168) {
+                        break;
+                    }
+                    message.usecAvgAll = reader.uint32();
+                    continue;
+                }
+                case 22: {
+                    if (tag !== 176) {
+                        break;
+                    }
+                    message.usecP50All = reader.uint32();
+                    continue;
+                }
+                case 23: {
+                    if (tag !== 184) {
+                        break;
+                    }
+                    message.usecP99All = reader.uint32();
+                    continue;
+                }
+                case 31: {
+                    if (tag !== 248) {
+                        break;
+                    }
+                    message.usec1secmaxAvgActive = reader.uint32();
+                    continue;
+                }
+                case 32: {
+                    if (tag !== 256) {
+                        break;
+                    }
+                    message.usec1secmaxP50Active = reader.uint32();
+                    continue;
+                }
+                case 33: {
+                    if (tag !== 264) {
+                        break;
+                    }
+                    message.usec1secmaxP95Active = reader.uint32();
+                    continue;
+                }
+                case 34: {
+                    if (tag !== 272) {
+                        break;
+                    }
+                    message.usec1secmaxP99Active = reader.uint32();
+                    continue;
+                }
+                case 41: {
+                    if (tag !== 328) {
+                        break;
+                    }
+                    message.usec1secmaxAvgAll = reader.uint32();
+                    continue;
+                }
+                case 42: {
+                    if (tag !== 336) {
+                        break;
+                    }
+                    message.usec1secmaxP50All = reader.uint32();
+                    continue;
+                }
+                case 43: {
+                    if (tag !== 344) {
+                        break;
+                    }
+                    message.usec1secmaxP95All = reader.uint32();
+                    continue;
+                }
+                case 44: {
+                    if (tag !== 352) {
+                        break;
+                    }
+                    message.usec1secmaxP99All = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2VProfLiteReport() {
+    return { total: undefined, items: [], discardedFrames: 0 };
+}
+export const CMsgSource2VProfLiteReport = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.total !== undefined) {
+            CMsgSource2VProfLiteReportItem.encode(message.total, writer.uint32(10).fork()).join();
+        }
+        for (const v of message.items) {
+            CMsgSource2VProfLiteReportItem.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.discardedFrames !== undefined && message.discardedFrames !== 0) {
+            writer.uint32(24).uint32(message.discardedFrames);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2VProfLiteReport();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.total = CMsgSource2VProfLiteReportItem.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.items.push(CMsgSource2VProfLiteReportItem.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.discardedFrames = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2NetworkFlowQuality() {
+    return {
+        duration: 0,
+        bytesTotal: 0,
+        bytesTotalReliable: 0,
+        bytesTotalVoice: 0,
+        bytesSecP95: 0,
+        bytesSecP99: 0,
+        enginemsgsTotal: 0,
+        enginemsgsSecP95: 0,
+        enginemsgsSecP99: 0,
+        netframesTotal: 0,
+        netframesDropped: 0,
+        netframesOutoforder: 0,
+        netframesSizeExceedsMtu: 0,
+        netframesSizeP95: 0,
+        netframesSizeP99: 0,
+        ticksTotal: 0,
+        ticksGood: 0,
+        ticksGoodAlmostLate: 0,
+        ticksFixedDropped: 0,
+        ticksFixedLate: 0,
+        ticksBadDropped: 0,
+        ticksBadLate: 0,
+        ticksBadOther: 0,
+        tickMissrateSamplesTotal: 0,
+        tickMissrateSamplesPerfect: 0,
+        tickMissrateSamplesPerfectnet: 0,
+        tickMissratenetP75X10: 0,
+        tickMissratenetP95X10: 0,
+        tickMissratenetP99X10: 0,
+        recvmarginP1: 0,
+        recvmarginP5: 0,
+        recvmarginP25: 0,
+        recvmarginP50: 0,
+        recvmarginP75: 0,
+        recvmarginP95: 0,
+        netframeJitterP50: 0,
+        netframeJitterP99: 0,
+        intervalPeakjitterP50: 0,
+        intervalPeakjitterP95: 0,
+        packetMisdeliveryRateP50X4: 0,
+        packetMisdeliveryRateP95X4: 0,
+        netPingP5: 0,
+        netPingP50: 0,
+        netPingP95: 0,
+    };
+}
+export const CMsgSource2NetworkFlowQuality = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.duration !== undefined && message.duration !== 0) {
+            writer.uint32(8).uint32(message.duration);
+        }
+        if (message.bytesTotal !== undefined && message.bytesTotal !== 0) {
+            writer.uint32(40).uint64(message.bytesTotal);
+        }
+        if (message.bytesTotalReliable !== undefined && message.bytesTotalReliable !== 0) {
+            writer.uint32(48).uint64(message.bytesTotalReliable);
+        }
+        if (message.bytesTotalVoice !== undefined && message.bytesTotalVoice !== 0) {
+            writer.uint32(56).uint64(message.bytesTotalVoice);
+        }
+        if (message.bytesSecP95 !== undefined && message.bytesSecP95 !== 0) {
+            writer.uint32(80).uint32(message.bytesSecP95);
+        }
+        if (message.bytesSecP99 !== undefined && message.bytesSecP99 !== 0) {
+            writer.uint32(88).uint32(message.bytesSecP99);
+        }
+        if (message.enginemsgsTotal !== undefined && message.enginemsgsTotal !== 0) {
+            writer.uint32(160).uint32(message.enginemsgsTotal);
+        }
+        if (message.enginemsgsSecP95 !== undefined && message.enginemsgsSecP95 !== 0) {
+            writer.uint32(168).uint32(message.enginemsgsSecP95);
+        }
+        if (message.enginemsgsSecP99 !== undefined && message.enginemsgsSecP99 !== 0) {
+            writer.uint32(176).uint32(message.enginemsgsSecP99);
+        }
+        if (message.netframesTotal !== undefined && message.netframesTotal !== 0) {
+            writer.uint32(240).uint32(message.netframesTotal);
+        }
+        if (message.netframesDropped !== undefined && message.netframesDropped !== 0) {
+            writer.uint32(248).uint32(message.netframesDropped);
+        }
+        if (message.netframesOutoforder !== undefined && message.netframesOutoforder !== 0) {
+            writer.uint32(256).uint32(message.netframesOutoforder);
+        }
+        if (message.netframesSizeExceedsMtu !== undefined && message.netframesSizeExceedsMtu !== 0) {
+            writer.uint32(272).uint32(message.netframesSizeExceedsMtu);
+        }
+        if (message.netframesSizeP95 !== undefined && message.netframesSizeP95 !== 0) {
+            writer.uint32(280).uint32(message.netframesSizeP95);
+        }
+        if (message.netframesSizeP99 !== undefined && message.netframesSizeP99 !== 0) {
+            writer.uint32(288).uint32(message.netframesSizeP99);
+        }
+        if (message.ticksTotal !== undefined && message.ticksTotal !== 0) {
+            writer.uint32(320).uint32(message.ticksTotal);
+        }
+        if (message.ticksGood !== undefined && message.ticksGood !== 0) {
+            writer.uint32(328).uint32(message.ticksGood);
+        }
+        if (message.ticksGoodAlmostLate !== undefined && message.ticksGoodAlmostLate !== 0) {
+            writer.uint32(336).uint32(message.ticksGoodAlmostLate);
+        }
+        if (message.ticksFixedDropped !== undefined && message.ticksFixedDropped !== 0) {
+            writer.uint32(344).uint32(message.ticksFixedDropped);
+        }
+        if (message.ticksFixedLate !== undefined && message.ticksFixedLate !== 0) {
+            writer.uint32(352).uint32(message.ticksFixedLate);
+        }
+        if (message.ticksBadDropped !== undefined && message.ticksBadDropped !== 0) {
+            writer.uint32(360).uint32(message.ticksBadDropped);
+        }
+        if (message.ticksBadLate !== undefined && message.ticksBadLate !== 0) {
+            writer.uint32(368).uint32(message.ticksBadLate);
+        }
+        if (message.ticksBadOther !== undefined && message.ticksBadOther !== 0) {
+            writer.uint32(376).uint32(message.ticksBadOther);
+        }
+        if (message.tickMissrateSamplesTotal !== undefined && message.tickMissrateSamplesTotal !== 0) {
+            writer.uint32(400).uint32(message.tickMissrateSamplesTotal);
+        }
+        if (message.tickMissrateSamplesPerfect !== undefined && message.tickMissrateSamplesPerfect !== 0) {
+            writer.uint32(408).uint32(message.tickMissrateSamplesPerfect);
+        }
+        if (message.tickMissrateSamplesPerfectnet !== undefined && message.tickMissrateSamplesPerfectnet !== 0) {
+            writer.uint32(416).uint32(message.tickMissrateSamplesPerfectnet);
+        }
+        if (message.tickMissratenetP75X10 !== undefined && message.tickMissratenetP75X10 !== 0) {
+            writer.uint32(424).uint32(message.tickMissratenetP75X10);
+        }
+        if (message.tickMissratenetP95X10 !== undefined && message.tickMissratenetP95X10 !== 0) {
+            writer.uint32(432).uint32(message.tickMissratenetP95X10);
+        }
+        if (message.tickMissratenetP99X10 !== undefined && message.tickMissratenetP99X10 !== 0) {
+            writer.uint32(440).uint32(message.tickMissratenetP99X10);
+        }
+        if (message.recvmarginP1 !== undefined && message.recvmarginP1 !== 0) {
+            writer.uint32(488).sint32(message.recvmarginP1);
+        }
+        if (message.recvmarginP5 !== undefined && message.recvmarginP5 !== 0) {
+            writer.uint32(496).sint32(message.recvmarginP5);
+        }
+        if (message.recvmarginP25 !== undefined && message.recvmarginP25 !== 0) {
+            writer.uint32(504).sint32(message.recvmarginP25);
+        }
+        if (message.recvmarginP50 !== undefined && message.recvmarginP50 !== 0) {
+            writer.uint32(512).sint32(message.recvmarginP50);
+        }
+        if (message.recvmarginP75 !== undefined && message.recvmarginP75 !== 0) {
+            writer.uint32(520).sint32(message.recvmarginP75);
+        }
+        if (message.recvmarginP95 !== undefined && message.recvmarginP95 !== 0) {
+            writer.uint32(528).sint32(message.recvmarginP95);
+        }
+        if (message.netframeJitterP50 !== undefined && message.netframeJitterP50 !== 0) {
+            writer.uint32(560).uint32(message.netframeJitterP50);
+        }
+        if (message.netframeJitterP99 !== undefined && message.netframeJitterP99 !== 0) {
+            writer.uint32(568).uint32(message.netframeJitterP99);
+        }
+        if (message.intervalPeakjitterP50 !== undefined && message.intervalPeakjitterP50 !== 0) {
+            writer.uint32(576).uint32(message.intervalPeakjitterP50);
+        }
+        if (message.intervalPeakjitterP95 !== undefined && message.intervalPeakjitterP95 !== 0) {
+            writer.uint32(584).uint32(message.intervalPeakjitterP95);
+        }
+        if (message.packetMisdeliveryRateP50X4 !== undefined && message.packetMisdeliveryRateP50X4 !== 0) {
+            writer.uint32(592).uint32(message.packetMisdeliveryRateP50X4);
+        }
+        if (message.packetMisdeliveryRateP95X4 !== undefined && message.packetMisdeliveryRateP95X4 !== 0) {
+            writer.uint32(600).uint32(message.packetMisdeliveryRateP95X4);
+        }
+        if (message.netPingP5 !== undefined && message.netPingP5 !== 0) {
+            writer.uint32(640).uint32(message.netPingP5);
+        }
+        if (message.netPingP50 !== undefined && message.netPingP50 !== 0) {
+            writer.uint32(648).uint32(message.netPingP50);
+        }
+        if (message.netPingP95 !== undefined && message.netPingP95 !== 0) {
+            writer.uint32(656).uint32(message.netPingP95);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2NetworkFlowQuality();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.duration = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.bytesTotal = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.bytesTotalReliable = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.bytesTotalVoice = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.bytesSecP95 = reader.uint32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.bytesSecP99 = reader.uint32();
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 160) {
+                        break;
+                    }
+                    message.enginemsgsTotal = reader.uint32();
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 168) {
+                        break;
+                    }
+                    message.enginemsgsSecP95 = reader.uint32();
+                    continue;
+                }
+                case 22: {
+                    if (tag !== 176) {
+                        break;
+                    }
+                    message.enginemsgsSecP99 = reader.uint32();
+                    continue;
+                }
+                case 30: {
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.netframesTotal = reader.uint32();
+                    continue;
+                }
+                case 31: {
+                    if (tag !== 248) {
+                        break;
+                    }
+                    message.netframesDropped = reader.uint32();
+                    continue;
+                }
+                case 32: {
+                    if (tag !== 256) {
+                        break;
+                    }
+                    message.netframesOutoforder = reader.uint32();
+                    continue;
+                }
+                case 34: {
+                    if (tag !== 272) {
+                        break;
+                    }
+                    message.netframesSizeExceedsMtu = reader.uint32();
+                    continue;
+                }
+                case 35: {
+                    if (tag !== 280) {
+                        break;
+                    }
+                    message.netframesSizeP95 = reader.uint32();
+                    continue;
+                }
+                case 36: {
+                    if (tag !== 288) {
+                        break;
+                    }
+                    message.netframesSizeP99 = reader.uint32();
+                    continue;
+                }
+                case 40: {
+                    if (tag !== 320) {
+                        break;
+                    }
+                    message.ticksTotal = reader.uint32();
+                    continue;
+                }
+                case 41: {
+                    if (tag !== 328) {
+                        break;
+                    }
+                    message.ticksGood = reader.uint32();
+                    continue;
+                }
+                case 42: {
+                    if (tag !== 336) {
+                        break;
+                    }
+                    message.ticksGoodAlmostLate = reader.uint32();
+                    continue;
+                }
+                case 43: {
+                    if (tag !== 344) {
+                        break;
+                    }
+                    message.ticksFixedDropped = reader.uint32();
+                    continue;
+                }
+                case 44: {
+                    if (tag !== 352) {
+                        break;
+                    }
+                    message.ticksFixedLate = reader.uint32();
+                    continue;
+                }
+                case 45: {
+                    if (tag !== 360) {
+                        break;
+                    }
+                    message.ticksBadDropped = reader.uint32();
+                    continue;
+                }
+                case 46: {
+                    if (tag !== 368) {
+                        break;
+                    }
+                    message.ticksBadLate = reader.uint32();
+                    continue;
+                }
+                case 47: {
+                    if (tag !== 376) {
+                        break;
+                    }
+                    message.ticksBadOther = reader.uint32();
+                    continue;
+                }
+                case 50: {
+                    if (tag !== 400) {
+                        break;
+                    }
+                    message.tickMissrateSamplesTotal = reader.uint32();
+                    continue;
+                }
+                case 51: {
+                    if (tag !== 408) {
+                        break;
+                    }
+                    message.tickMissrateSamplesPerfect = reader.uint32();
+                    continue;
+                }
+                case 52: {
+                    if (tag !== 416) {
+                        break;
+                    }
+                    message.tickMissrateSamplesPerfectnet = reader.uint32();
+                    continue;
+                }
+                case 53: {
+                    if (tag !== 424) {
+                        break;
+                    }
+                    message.tickMissratenetP75X10 = reader.uint32();
+                    continue;
+                }
+                case 54: {
+                    if (tag !== 432) {
+                        break;
+                    }
+                    message.tickMissratenetP95X10 = reader.uint32();
+                    continue;
+                }
+                case 55: {
+                    if (tag !== 440) {
+                        break;
+                    }
+                    message.tickMissratenetP99X10 = reader.uint32();
+                    continue;
+                }
+                case 61: {
+                    if (tag !== 488) {
+                        break;
+                    }
+                    message.recvmarginP1 = reader.sint32();
+                    continue;
+                }
+                case 62: {
+                    if (tag !== 496) {
+                        break;
+                    }
+                    message.recvmarginP5 = reader.sint32();
+                    continue;
+                }
+                case 63: {
+                    if (tag !== 504) {
+                        break;
+                    }
+                    message.recvmarginP25 = reader.sint32();
+                    continue;
+                }
+                case 64: {
+                    if (tag !== 512) {
+                        break;
+                    }
+                    message.recvmarginP50 = reader.sint32();
+                    continue;
+                }
+                case 65: {
+                    if (tag !== 520) {
+                        break;
+                    }
+                    message.recvmarginP75 = reader.sint32();
+                    continue;
+                }
+                case 66: {
+                    if (tag !== 528) {
+                        break;
+                    }
+                    message.recvmarginP95 = reader.sint32();
+                    continue;
+                }
+                case 70: {
+                    if (tag !== 560) {
+                        break;
+                    }
+                    message.netframeJitterP50 = reader.uint32();
+                    continue;
+                }
+                case 71: {
+                    if (tag !== 568) {
+                        break;
+                    }
+                    message.netframeJitterP99 = reader.uint32();
+                    continue;
+                }
+                case 72: {
+                    if (tag !== 576) {
+                        break;
+                    }
+                    message.intervalPeakjitterP50 = reader.uint32();
+                    continue;
+                }
+                case 73: {
+                    if (tag !== 584) {
+                        break;
+                    }
+                    message.intervalPeakjitterP95 = reader.uint32();
+                    continue;
+                }
+                case 74: {
+                    if (tag !== 592) {
+                        break;
+                    }
+                    message.packetMisdeliveryRateP50X4 = reader.uint32();
+                    continue;
+                }
+                case 75: {
+                    if (tag !== 600) {
+                        break;
+                    }
+                    message.packetMisdeliveryRateP95X4 = reader.uint32();
+                    continue;
+                }
+                case 80: {
+                    if (tag !== 640) {
+                        break;
+                    }
+                    message.netPingP5 = reader.uint32();
+                    continue;
+                }
+                case 81: {
+                    if (tag !== 648) {
+                        break;
+                    }
+                    message.netPingP50 = reader.uint32();
+                    continue;
+                }
+                case 82: {
+                    if (tag !== 656) {
+                        break;
+                    }
+                    message.netPingP95 = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2PerfIntervalSample() {
+    return { frameTimeMaxMs: 0, frameTimeAvgMs: 0, frameTimeMinMs: 0, frameCount: 0, frameTimeTotalMs: 0, tags: [] };
+}
+export const CMsgSource2PerfIntervalSample = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.frameTimeMaxMs !== undefined && message.frameTimeMaxMs !== 0) {
+            writer.uint32(13).float(message.frameTimeMaxMs);
+        }
+        if (message.frameTimeAvgMs !== undefined && message.frameTimeAvgMs !== 0) {
+            writer.uint32(21).float(message.frameTimeAvgMs);
+        }
+        if (message.frameTimeMinMs !== undefined && message.frameTimeMinMs !== 0) {
+            writer.uint32(29).float(message.frameTimeMinMs);
+        }
+        if (message.frameCount !== undefined && message.frameCount !== 0) {
+            writer.uint32(32).int32(message.frameCount);
+        }
+        if (message.frameTimeTotalMs !== undefined && message.frameTimeTotalMs !== 0) {
+            writer.uint32(45).float(message.frameTimeTotalMs);
+        }
+        for (const v of message.tags) {
+            CMsgSource2PerfIntervalSample_Tag.encode(v, writer.uint32(50).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2PerfIntervalSample();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.frameTimeMaxMs = reader.float();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.frameTimeAvgMs = reader.float();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.frameTimeMinMs = reader.float();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.frameCount = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.frameTimeTotalMs = reader.float();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.tags.push(CMsgSource2PerfIntervalSample_Tag.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2PerfIntervalSample_Tag() {
+    return { tag: "", maxValue: 0 };
+}
+export const CMsgSource2PerfIntervalSample_Tag = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.tag !== undefined && message.tag !== "") {
+            writer.uint32(10).string(message.tag);
+        }
+        if (message.maxValue !== undefined && message.maxValue !== 0) {
+            writer.uint32(16).uint32(message.maxValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2PerfIntervalSample_Tag();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.tag = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.maxValue = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsMatchPerfSummaryNotification() {
+    return { appid: 0, gameMode: "", serverBuildId: 0, serverPopid: 0, serverProfile: undefined, clients: [], map: "" };
+}
+export const CSource2MetricsMatchPerfSummaryNotification = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.appid !== undefined && message.appid !== 0) {
+            writer.uint32(8).uint32(message.appid);
+        }
+        if (message.gameMode !== undefined && message.gameMode !== "") {
+            writer.uint32(18).string(message.gameMode);
+        }
+        if (message.serverBuildId !== undefined && message.serverBuildId !== 0) {
+            writer.uint32(24).uint32(message.serverBuildId);
+        }
+        if (message.serverPopid !== undefined && message.serverPopid !== 0) {
+            writer.uint32(37).fixed32(message.serverPopid);
+        }
+        if (message.serverProfile !== undefined) {
+            CMsgSource2VProfLiteReport.encode(message.serverProfile, writer.uint32(82).fork()).join();
+        }
+        for (const v of message.clients) {
+            CSource2MetricsMatchPerfSummaryNotification_Client.encode(v, writer.uint32(90).fork()).join();
+        }
+        if (message.map !== undefined && message.map !== "") {
+            writer.uint32(162).string(message.map);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsMatchPerfSummaryNotification();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.appid = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.gameMode = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.serverBuildId = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 37) {
+                        break;
+                    }
+                    message.serverPopid = reader.fixed32();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.serverProfile = CMsgSource2VProfLiteReport.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.clients.push(CSource2MetricsMatchPerfSummaryNotification_Client.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.map = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsMatchPerfSummaryNotification_Client() {
+    return {
+        systemSpecs: undefined,
+        profile: undefined,
+        buildId: 0,
+        downstreamFlow: undefined,
+        upstreamFlow: undefined,
+        steamid: 0,
+        perfSamples: [],
+    };
+}
+export const CSource2MetricsMatchPerfSummaryNotification_Client = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.systemSpecs !== undefined) {
+            CMsgSource2SystemSpecs.encode(message.systemSpecs, writer.uint32(10).fork()).join();
+        }
+        if (message.profile !== undefined) {
+            CMsgSource2VProfLiteReport.encode(message.profile, writer.uint32(18).fork()).join();
+        }
+        if (message.buildId !== undefined && message.buildId !== 0) {
+            writer.uint32(24).uint32(message.buildId);
+        }
+        if (message.downstreamFlow !== undefined) {
+            CMsgSource2NetworkFlowQuality.encode(message.downstreamFlow, writer.uint32(34).fork()).join();
+        }
+        if (message.upstreamFlow !== undefined) {
+            CMsgSource2NetworkFlowQuality.encode(message.upstreamFlow, writer.uint32(42).fork()).join();
+        }
+        if (message.steamid !== undefined && message.steamid !== 0) {
+            writer.uint32(81).fixed64(message.steamid);
+        }
+        for (const v of message.perfSamples) {
+            CMsgSource2PerfIntervalSample.encode(v, writer.uint32(90).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsMatchPerfSummaryNotification_Client();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.systemSpecs = CMsgSource2SystemSpecs.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.profile = CMsgSource2VProfLiteReport.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.buildId = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.downstreamFlow = CMsgSource2NetworkFlowQuality.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.upstreamFlow = CMsgSource2NetworkFlowQuality.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 81) {
+                        break;
+                    }
+                    message.steamid = longToNumber(reader.fixed64());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.perfSamples.push(CMsgSource2PerfIntervalSample.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2PlayStatsPackedRecordList() {
+    return {
+        recordName: "",
+        fieldDefs: [],
+        recordCount: 0,
+        uint64Vals: [],
+        uint32Vals: [],
+        uint16Vals: [],
+        uint8Vals: [],
+        int64Vals: [],
+        int32Vals: [],
+        int16Vals: [],
+        int8Vals: [],
+        float64Vals: [],
+        float32Vals: [],
+        boolVals: [],
+        stringVals: [],
+        lowCardinalityStringVals: [],
+        utcdatetimeVals: [],
+        steamidtrustbucketVals: [],
+        trustbucketVals: [],
+        steamidVals: [],
+    };
+}
+export const CMsgSource2PlayStatsPackedRecordList = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.recordName !== undefined && message.recordName !== "") {
+            writer.uint32(10).string(message.recordName);
+        }
+        for (const v of message.fieldDefs) {
+            CMsgSource2PlayStatsPackedRecordList_FieldDef.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.recordCount !== undefined && message.recordCount !== 0) {
+            writer.uint32(24).uint32(message.recordCount);
+        }
+        writer.uint32(34).fork();
+        for (const v of message.uint64Vals) {
+            writer.uint64(v);
+        }
+        writer.join();
+        writer.uint32(42).fork();
+        for (const v of message.uint32Vals) {
+            writer.uint32(v);
+        }
+        writer.join();
+        writer.uint32(50).fork();
+        for (const v of message.uint16Vals) {
+            writer.uint32(v);
+        }
+        writer.join();
+        writer.uint32(58).fork();
+        for (const v of message.uint8Vals) {
+            writer.uint32(v);
+        }
+        writer.join();
+        writer.uint32(66).fork();
+        for (const v of message.int64Vals) {
+            writer.int64(v);
+        }
+        writer.join();
+        writer.uint32(74).fork();
+        for (const v of message.int32Vals) {
+            writer.int32(v);
+        }
+        writer.join();
+        writer.uint32(82).fork();
+        for (const v of message.int16Vals) {
+            writer.int32(v);
+        }
+        writer.join();
+        writer.uint32(90).fork();
+        for (const v of message.int8Vals) {
+            writer.int32(v);
+        }
+        writer.join();
+        writer.uint32(98).fork();
+        for (const v of message.float64Vals) {
+            writer.double(v);
+        }
+        writer.join();
+        writer.uint32(106).fork();
+        for (const v of message.float32Vals) {
+            writer.float(v);
+        }
+        writer.join();
+        writer.uint32(114).fork();
+        for (const v of message.boolVals) {
+            writer.bool(v);
+        }
+        writer.join();
+        for (const v of message.stringVals) {
+            writer.uint32(122).string(v);
+        }
+        for (const v of message.lowCardinalityStringVals) {
+            writer.uint32(130).string(v);
+        }
+        writer.uint32(138).fork();
+        for (const v of message.utcdatetimeVals) {
+            writer.fixed32(v);
+        }
+        writer.join();
+        writer.uint32(146).fork();
+        for (const v of message.steamidtrustbucketVals) {
+            writer.fixed64(v);
+        }
+        writer.join();
+        for (const v of message.trustbucketVals) {
+            CMsgSource2PlayStatsPackedRecordList_SteamIDList.encode(v, writer.uint32(154).fork()).join();
+        }
+        writer.uint32(162).fork();
+        for (const v of message.steamidVals) {
+            writer.uint64(v);
+        }
+        writer.join();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2PlayStatsPackedRecordList();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.recordName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.fieldDefs.push(CMsgSource2PlayStatsPackedRecordList_FieldDef.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.recordCount = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag === 32) {
+                        message.uint64Vals.push(longToNumber(reader.uint64()));
+                        continue;
+                    }
+                    if (tag === 34) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uint64Vals.push(longToNumber(reader.uint64()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 5: {
+                    if (tag === 40) {
+                        message.uint32Vals.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 42) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uint32Vals.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 6: {
+                    if (tag === 48) {
+                        message.uint16Vals.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uint16Vals.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 56) {
+                        message.uint8Vals.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uint8Vals.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 64) {
+                        message.int64Vals.push(longToNumber(reader.int64()));
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.int64Vals.push(longToNumber(reader.int64()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 9: {
+                    if (tag === 72) {
+                        message.int32Vals.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 74) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.int32Vals.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 10: {
+                    if (tag === 80) {
+                        message.int16Vals.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 82) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.int16Vals.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 11: {
+                    if (tag === 88) {
+                        message.int8Vals.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 90) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.int8Vals.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 12: {
+                    if (tag === 97) {
+                        message.float64Vals.push(reader.double());
+                        continue;
+                    }
+                    if (tag === 98) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.float64Vals.push(reader.double());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 13: {
+                    if (tag === 109) {
+                        message.float32Vals.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 106) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.float32Vals.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 14: {
+                    if (tag === 112) {
+                        message.boolVals.push(reader.bool());
+                        continue;
+                    }
+                    if (tag === 114) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.boolVals.push(reader.bool());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.stringVals.push(reader.string());
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.lowCardinalityStringVals.push(reader.string());
+                    continue;
+                }
+                case 17: {
+                    if (tag === 141) {
+                        message.utcdatetimeVals.push(reader.fixed32());
+                        continue;
+                    }
+                    if (tag === 138) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.utcdatetimeVals.push(reader.fixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 18: {
+                    if (tag === 145) {
+                        message.steamidtrustbucketVals.push(longToNumber(reader.fixed64()));
+                        continue;
+                    }
+                    if (tag === 146) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.steamidtrustbucketVals.push(longToNumber(reader.fixed64()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 19: {
+                    if (tag !== 154) {
+                        break;
+                    }
+                    message.trustbucketVals.push(CMsgSource2PlayStatsPackedRecordList_SteamIDList.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 20: {
+                    if (tag === 160) {
+                        message.steamidVals.push(longToNumber(reader.uint64()));
+                        continue;
+                    }
+                    if (tag === 162) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.steamidVals.push(longToNumber(reader.uint64()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2PlayStatsPackedRecordList_FieldDef() {
+    return { fieldName: "", fieldType: 0 };
+}
+export const CMsgSource2PlayStatsPackedRecordList_FieldDef = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.fieldName !== undefined && message.fieldName !== "") {
+            writer.uint32(10).string(message.fieldName);
+        }
+        if (message.fieldType !== undefined && message.fieldType !== 0) {
+            writer.uint32(16).int32(message.fieldType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2PlayStatsPackedRecordList_FieldDef();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fieldName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.fieldType = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgSource2PlayStatsPackedRecordList_SteamIDList() {
+    return { steamid: [] };
+}
+export const CMsgSource2PlayStatsPackedRecordList_SteamIDList = {
+    encode(message, writer = new BinaryWriter()) {
+        writer.uint32(10).fork();
+        for (const v of message.steamid) {
+            writer.fixed64(v);
+        }
+        writer.join();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgSource2PlayStatsPackedRecordList_SteamIDList();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag === 9) {
+                        message.steamid.push(longToNumber(reader.fixed64()));
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.steamid.push(longToNumber(reader.fixed64()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsRecordPlayStatsNotification() {
+    return { recordTypes: [], appid: 0 };
+}
+export const CSource2MetricsRecordPlayStatsNotification = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.recordTypes) {
+            CMsgSource2PlayStatsPackedRecordList.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.appid !== undefined && message.appid !== 0) {
+            writer.uint32(16).uint32(message.appid);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsRecordPlayStatsNotification();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.recordTypes.push(CMsgSource2PlayStatsPackedRecordList.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.appid = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsFetchMapDataRequest() {
+    return { appid: 0, mapName: "", gameType: 0, gameMode: 0, param: "", timeSpan: 0 };
+}
+export const CSource2MetricsFetchMapDataRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.appid !== undefined && message.appid !== 0) {
+            writer.uint32(8).uint32(message.appid);
+        }
+        if (message.mapName !== undefined && message.mapName !== "") {
+            writer.uint32(18).string(message.mapName);
+        }
+        if (message.gameType !== undefined && message.gameType !== 0) {
+            writer.uint32(24).uint32(message.gameType);
+        }
+        if (message.gameMode !== undefined && message.gameMode !== 0) {
+            writer.uint32(32).uint32(message.gameMode);
+        }
+        if (message.param !== undefined && message.param !== "") {
+            writer.uint32(42).string(message.param);
+        }
+        if (message.timeSpan !== undefined && message.timeSpan !== 0) {
+            writer.uint32(48).uint32(message.timeSpan);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsFetchMapDataRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.appid = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.mapName = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.gameType = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.gameMode = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.param = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.timeSpan = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsFetchMapDataResponse() {
+    return { results: [] };
+}
+export const CSource2MetricsFetchMapDataResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.results) {
+            CSource2MetricsFetchMapDataResponse_MapData.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsFetchMapDataResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.results.push(CSource2MetricsFetchMapDataResponse_MapData.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSource2MetricsFetchMapDataResponse_MapData() {
+    return { name: "", type: "", data: "" };
+}
+export const CSource2MetricsFetchMapDataResponse_MapData = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== undefined && message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.type !== undefined && message.type !== "") {
+            writer.uint32(18).string(message.type);
+        }
+        if (message.data !== undefined && message.data !== "") {
+            writer.uint32(26).string(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCSource2MetricsFetchMapDataResponse_MapData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.type = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.data = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCUserMessageUserSentBugBug() {
+    return { commandLine: "", autoexecCfg: "", systemSpecs: undefined, buildId: 0, osversion: 0, commandLogs: "" };
+}
+export const CUserMessageUserSentBugBug = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.commandLine !== undefined && message.commandLine !== "") {
+            writer.uint32(10).string(message.commandLine);
+        }
+        if (message.autoexecCfg !== undefined && message.autoexecCfg !== "") {
+            writer.uint32(18).string(message.autoexecCfg);
+        }
+        if (message.systemSpecs !== undefined) {
+            CMsgSource2SystemSpecs.encode(message.systemSpecs, writer.uint32(26).fork()).join();
+        }
+        if (message.buildId !== undefined && message.buildId !== 0) {
+            writer.uint32(32).uint32(message.buildId);
+        }
+        if (message.osversion !== undefined && message.osversion !== 0) {
+            writer.uint32(40).int32(message.osversion);
+        }
+        if (message.commandLogs !== undefined && message.commandLogs !== "") {
+            writer.uint32(50).string(message.commandLogs);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCUserMessageUserSentBugBug();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.commandLine = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.autoexecCfg = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.systemSpecs = CMsgSource2SystemSpecs.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.buildId = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.osversion = reader.int32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.commandLogs = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}