cs2-protobuf 1.0.1

package/.dist/generated/cs_gameevents.wrapper.js

@@ -0,0 +1,47 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: cs_gameevents.ts
+/* eslint-disable */
+export * from "./cs_gameevents.js";
+import * as GeneratedTypescript from "./cs_gameevents.js";
+export const CMsgTEPlayerAnimEvent = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEPlayerAnimEvent.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEPlayerAnimEvent.decode(input);
+    },
+};
+export const CMsgTERadioIcon = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTERadioIcon.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTERadioIcon.decode(input);
+    },
+};
+export const CMsgTEFireBullets = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEFireBullets.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEFireBullets.decode(input);
+    },
+};
+export const CMsgTEFireBullets_Extra = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEFireBullets_Extra.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEFireBullets_Extra.decode(input);
+    },
+};
+export const CMsgPlayerBulletHit = {
+    encode(message) {
+        return GeneratedTypescript.CMsgPlayerBulletHit.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgPlayerBulletHit.decode(input);
+    },
+};

package/.dist/generated/cs_prediction_events.d.ts

@@ -0,0 +1,16 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare enum ECSPredictionEvents {
+    CSPE_DamageTag = 1,
+    UNRECOGNIZED = -1
+}
+export interface CCSPredictionEventDamageTag {
+    flinchModSmall?: number | undefined;
+    flinchModLarge?: number | undefined;
+    friendlyFireDamageReductionRatio?: number | undefined;
+}
+export declare const CCSPredictionEventDamageTag: MessageFns<CCSPredictionEventDamageTag>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};

package/.dist/generated/cs_prediction_events.js

@@ -0,0 +1,65 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: cs_prediction_events.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export var ECSPredictionEvents;
+(function (ECSPredictionEvents) {
+    ECSPredictionEvents[ECSPredictionEvents["CSPE_DamageTag"] = 1] = "CSPE_DamageTag";
+    ECSPredictionEvents[ECSPredictionEvents["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ECSPredictionEvents || (ECSPredictionEvents = {}));
+function createBaseCCSPredictionEventDamageTag() {
+    return { flinchModSmall: 0, flinchModLarge: 0, friendlyFireDamageReductionRatio: 0 };
+}
+export const CCSPredictionEventDamageTag = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.flinchModSmall !== undefined && message.flinchModSmall !== 0) {
+            writer.uint32(13).float(message.flinchModSmall);
+        }
+        if (message.flinchModLarge !== undefined && message.flinchModLarge !== 0) {
+            writer.uint32(21).float(message.flinchModLarge);
+        }
+        if (message.friendlyFireDamageReductionRatio !== undefined && message.friendlyFireDamageReductionRatio !== 0) {
+            writer.uint32(29).float(message.friendlyFireDamageReductionRatio);
+        }
+        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 = createBaseCCSPredictionEventDamageTag();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.flinchModSmall = reader.float();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.flinchModLarge = reader.float();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.friendlyFireDamageReductionRatio = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};

package/.dist/generated/cs_prediction_events.wrapper.d.ts

@@ -0,0 +1,6 @@
+export * from "./cs_prediction_events.js";
+import * as GeneratedTypescript from "./cs_prediction_events.js";
+export declare const CCSPredictionEventDamageTag: {
+    encode(message: GeneratedTypescript.CCSPredictionEventDamageTag): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CCSPredictionEventDamageTag;
+};

package/.dist/generated/cs_prediction_events.wrapper.js

@@ -0,0 +1,15 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: cs_prediction_events.ts
+/* eslint-disable */
+export * from "./cs_prediction_events.js";
+import * as GeneratedTypescript from "./cs_prediction_events.js";
+export const CCSPredictionEventDamageTag = {
+    encode(message) {
+        return GeneratedTypescript.CCSPredictionEventDamageTag.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CCSPredictionEventDamageTag.decode(input);
+    },
+};

package/.dist/generated/cs_usercmd.d.ts

@@ -0,0 +1,47 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+import { CBaseUserCmdPB } from "./usercmd.js";
+export interface CSGOInterpolationInfoPB {
+    srcTick?: number | undefined;
+    dstTick?: number | undefined;
+    frac?: number | undefined;
+}
+export interface CSGOInterpolationInfoPBCL {
+    frac?: number | undefined;
+}
+export interface CSGOInputHistoryEntryPB {
+    viewAngles?: CMsgQAngle | undefined;
+    renderTickCount?: number | undefined;
+    renderTickFraction?: number | undefined;
+    playerTickCount?: number | undefined;
+    playerTickFraction?: number | undefined;
+    clInterp?: CSGOInterpolationInfoPBCL | undefined;
+    svInterp0?: CSGOInterpolationInfoPB | undefined;
+    svInterp1?: CSGOInterpolationInfoPB | undefined;
+    playerInterp?: CSGOInterpolationInfoPB | undefined;
+    frameNumber?: number | undefined;
+    targetEntIndex?: number | undefined;
+    shootPosition?: CMsgVector | undefined;
+    targetHeadPosCheck?: CMsgVector | undefined;
+    targetAbsPosCheck?: CMsgVector | undefined;
+    targetAbsAngCheck?: CMsgQAngle | undefined;
+}
+export interface CSGOUserCmdPB {
+    base?: CBaseUserCmdPB | undefined;
+    inputHistory: CSGOInputHistoryEntryPB[];
+    attack1StartHistoryIndex?: number | undefined;
+    attack2StartHistoryIndex?: number | undefined;
+    leftHandDesired?: boolean | undefined;
+    isPredictingBodyShotFx?: boolean | undefined;
+    isPredictingHeadShotFx?: boolean | undefined;
+    isPredictingKillRagdolls?: boolean | undefined;
+}
+export declare const CSGOInterpolationInfoPB: MessageFns<CSGOInterpolationInfoPB>;
+export declare const CSGOInterpolationInfoPBCL: MessageFns<CSGOInterpolationInfoPBCL>;
+export declare const CSGOInputHistoryEntryPB: MessageFns<CSGOInputHistoryEntryPB>;
+export declare const CSGOUserCmdPB: MessageFns<CSGOUserCmdPB>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};

package/.dist/generated/cs_usercmd.js

@@ -0,0 +1,396 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: cs_usercmd.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+import { CBaseUserCmdPB } from "./usercmd.js";
+function createBaseCSGOInterpolationInfoPB() {
+    return { srcTick: -1, dstTick: -1, frac: 0 };
+}
+export const CSGOInterpolationInfoPB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.srcTick !== undefined && message.srcTick !== -1) {
+            writer.uint32(8).int32(message.srcTick);
+        }
+        if (message.dstTick !== undefined && message.dstTick !== -1) {
+            writer.uint32(16).int32(message.dstTick);
+        }
+        if (message.frac !== undefined && message.frac !== 0) {
+            writer.uint32(29).float(message.frac);
+        }
+        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 = createBaseCSGOInterpolationInfoPB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.srcTick = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.dstTick = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.frac = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSGOInterpolationInfoPBCL() {
+    return { frac: 0 };
+}
+export const CSGOInterpolationInfoPBCL = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.frac !== undefined && message.frac !== 0) {
+            writer.uint32(29).float(message.frac);
+        }
+        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 = createBaseCSGOInterpolationInfoPBCL();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.frac = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSGOInputHistoryEntryPB() {
+    return {
+        viewAngles: undefined,
+        renderTickCount: 0,
+        renderTickFraction: 0,
+        playerTickCount: 0,
+        playerTickFraction: 0,
+        clInterp: undefined,
+        svInterp0: undefined,
+        svInterp1: undefined,
+        playerInterp: undefined,
+        frameNumber: 0,
+        targetEntIndex: -1,
+        shootPosition: undefined,
+        targetHeadPosCheck: undefined,
+        targetAbsPosCheck: undefined,
+        targetAbsAngCheck: undefined,
+    };
+}
+export const CSGOInputHistoryEntryPB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.viewAngles !== undefined) {
+            CMsgQAngle.encode(message.viewAngles, writer.uint32(18).fork()).join();
+        }
+        if (message.renderTickCount !== undefined && message.renderTickCount !== 0) {
+            writer.uint32(32).int32(message.renderTickCount);
+        }
+        if (message.renderTickFraction !== undefined && message.renderTickFraction !== 0) {
+            writer.uint32(45).float(message.renderTickFraction);
+        }
+        if (message.playerTickCount !== undefined && message.playerTickCount !== 0) {
+            writer.uint32(48).int32(message.playerTickCount);
+        }
+        if (message.playerTickFraction !== undefined && message.playerTickFraction !== 0) {
+            writer.uint32(61).float(message.playerTickFraction);
+        }
+        if (message.clInterp !== undefined) {
+            CSGOInterpolationInfoPBCL.encode(message.clInterp, writer.uint32(98).fork()).join();
+        }
+        if (message.svInterp0 !== undefined) {
+            CSGOInterpolationInfoPB.encode(message.svInterp0, writer.uint32(106).fork()).join();
+        }
+        if (message.svInterp1 !== undefined) {
+            CSGOInterpolationInfoPB.encode(message.svInterp1, writer.uint32(114).fork()).join();
+        }
+        if (message.playerInterp !== undefined) {
+            CSGOInterpolationInfoPB.encode(message.playerInterp, writer.uint32(122).fork()).join();
+        }
+        if (message.frameNumber !== undefined && message.frameNumber !== 0) {
+            writer.uint32(512).int32(message.frameNumber);
+        }
+        if (message.targetEntIndex !== undefined && message.targetEntIndex !== -1) {
+            writer.uint32(520).int32(message.targetEntIndex);
+        }
+        if (message.shootPosition !== undefined) {
+            CMsgVector.encode(message.shootPosition, writer.uint32(530).fork()).join();
+        }
+        if (message.targetHeadPosCheck !== undefined) {
+            CMsgVector.encode(message.targetHeadPosCheck, writer.uint32(538).fork()).join();
+        }
+        if (message.targetAbsPosCheck !== undefined) {
+            CMsgVector.encode(message.targetAbsPosCheck, writer.uint32(546).fork()).join();
+        }
+        if (message.targetAbsAngCheck !== undefined) {
+            CMsgQAngle.encode(message.targetAbsAngCheck, writer.uint32(554).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 = createBaseCSGOInputHistoryEntryPB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.viewAngles = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.renderTickCount = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.renderTickFraction = reader.float();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.playerTickCount = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 61) {
+                        break;
+                    }
+                    message.playerTickFraction = reader.float();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.clInterp = CSGOInterpolationInfoPBCL.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.svInterp0 = CSGOInterpolationInfoPB.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.svInterp1 = CSGOInterpolationInfoPB.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.playerInterp = CSGOInterpolationInfoPB.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 64: {
+                    if (tag !== 512) {
+                        break;
+                    }
+                    message.frameNumber = reader.int32();
+                    continue;
+                }
+                case 65: {
+                    if (tag !== 520) {
+                        break;
+                    }
+                    message.targetEntIndex = reader.int32();
+                    continue;
+                }
+                case 66: {
+                    if (tag !== 530) {
+                        break;
+                    }
+                    message.shootPosition = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 67: {
+                    if (tag !== 538) {
+                        break;
+                    }
+                    message.targetHeadPosCheck = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 68: {
+                    if (tag !== 546) {
+                        break;
+                    }
+                    message.targetAbsPosCheck = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 69: {
+                    if (tag !== 554) {
+                        break;
+                    }
+                    message.targetAbsAngCheck = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSGOUserCmdPB() {
+    return {
+        base: undefined,
+        inputHistory: [],
+        attack1StartHistoryIndex: -1,
+        attack2StartHistoryIndex: -1,
+        leftHandDesired: false,
+        isPredictingBodyShotFx: false,
+        isPredictingHeadShotFx: false,
+        isPredictingKillRagdolls: false,
+    };
+}
+export const CSGOUserCmdPB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.base !== undefined) {
+            CBaseUserCmdPB.encode(message.base, writer.uint32(10).fork()).join();
+        }
+        for (const v of message.inputHistory) {
+            CSGOInputHistoryEntryPB.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.attack1StartHistoryIndex !== undefined && message.attack1StartHistoryIndex !== -1) {
+            writer.uint32(48).int32(message.attack1StartHistoryIndex);
+        }
+        if (message.attack2StartHistoryIndex !== undefined && message.attack2StartHistoryIndex !== -1) {
+            writer.uint32(56).int32(message.attack2StartHistoryIndex);
+        }
+        if (message.leftHandDesired !== undefined && message.leftHandDesired !== false) {
+            writer.uint32(72).bool(message.leftHandDesired);
+        }
+        if (message.isPredictingBodyShotFx !== undefined && message.isPredictingBodyShotFx !== false) {
+            writer.uint32(88).bool(message.isPredictingBodyShotFx);
+        }
+        if (message.isPredictingHeadShotFx !== undefined && message.isPredictingHeadShotFx !== false) {
+            writer.uint32(96).bool(message.isPredictingHeadShotFx);
+        }
+        if (message.isPredictingKillRagdolls !== undefined && message.isPredictingKillRagdolls !== false) {
+            writer.uint32(104).bool(message.isPredictingKillRagdolls);
+        }
+        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 = createBaseCSGOUserCmdPB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.base = CBaseUserCmdPB.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.inputHistory.push(CSGOInputHistoryEntryPB.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.attack1StartHistoryIndex = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.attack2StartHistoryIndex = reader.int32();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.leftHandDesired = reader.bool();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.isPredictingBodyShotFx = reader.bool();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.isPredictingHeadShotFx = reader.bool();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.isPredictingKillRagdolls = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};

package/.dist/generated/cs_usercmd.wrapper.d.ts

@@ -0,0 +1,18 @@
+export * from "./cs_usercmd.js";
+import * as GeneratedTypescript from "./cs_usercmd.js";
+export declare const CSGOInterpolationInfoPB: {
+    encode(message: GeneratedTypescript.CSGOInterpolationInfoPB): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSGOInterpolationInfoPB;
+};
+export declare const CSGOInterpolationInfoPBCL: {
+    encode(message: GeneratedTypescript.CSGOInterpolationInfoPBCL): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSGOInterpolationInfoPBCL;
+};
+export declare const CSGOInputHistoryEntryPB: {
+    encode(message: GeneratedTypescript.CSGOInputHistoryEntryPB): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSGOInputHistoryEntryPB;
+};
+export declare const CSGOUserCmdPB: {
+    encode(message: GeneratedTypescript.CSGOUserCmdPB): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSGOUserCmdPB;
+};

package/.dist/generated/cs_usercmd.wrapper.js

@@ -0,0 +1,39 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: cs_usercmd.ts
+/* eslint-disable */
+export * from "./cs_usercmd.js";
+import * as GeneratedTypescript from "./cs_usercmd.js";
+export const CSGOInterpolationInfoPB = {
+    encode(message) {
+        return GeneratedTypescript.CSGOInterpolationInfoPB.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSGOInterpolationInfoPB.decode(input);
+    },
+};
+export const CSGOInterpolationInfoPBCL = {
+    encode(message) {
+        return GeneratedTypescript.CSGOInterpolationInfoPBCL.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSGOInterpolationInfoPBCL.decode(input);
+    },
+};
+export const CSGOInputHistoryEntryPB = {
+    encode(message) {
+        return GeneratedTypescript.CSGOInputHistoryEntryPB.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSGOInputHistoryEntryPB.decode(input);
+    },
+};
+export const CSGOUserCmdPB = {
+    encode(message) {
+        return GeneratedTypescript.CSGOUserCmdPB.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSGOUserCmdPB.decode(input);
+    },
+};