cs2-protobuf 1.0.1

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

@@ -0,0 +1,110 @@
+export * from "./networkbasetypes.js";
+import * as GeneratedTypescript from "./networkbasetypes.js";
+export declare const CMsgVector: {
+    encode(message: GeneratedTypescript.CMsgVector): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgVector;
+};
+export declare const CMsgVector2D: {
+    encode(message: GeneratedTypescript.CMsgVector2D): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgVector2D;
+};
+export declare const CMsgQAngle: {
+    encode(message: GeneratedTypescript.CMsgQAngle): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgQAngle;
+};
+export declare const CMsgQuaternion: {
+    encode(message: GeneratedTypescript.CMsgQuaternion): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgQuaternion;
+};
+export declare const CMsgTransform: {
+    encode(message: GeneratedTypescript.CMsgTransform): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTransform;
+};
+export declare const CMsgRGBA: {
+    encode(message: GeneratedTypescript.CMsgRGBA): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgRGBA;
+};
+export declare const CMsgPlayerInfo: {
+    encode(message: GeneratedTypescript.CMsgPlayerInfo): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgPlayerInfo;
+};
+export declare const CEntityMsg: {
+    encode(message: GeneratedTypescript.CEntityMsg): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CEntityMsg;
+};
+export declare const CMsgCVars: {
+    encode(message: GeneratedTypescript.CMsgCVars): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgCVars;
+};
+export declare const CMsgCVars_CVar: {
+    encode(message: GeneratedTypescript.CMsgCVars_CVar): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgCVars_CVar;
+};
+export declare const CNETMsgNOP: {
+    encode(message: GeneratedTypescript.CNETMsgNOP): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgNOP;
+};
+export declare const CNETMsgSplitScreenUser: {
+    encode(message: GeneratedTypescript.CNETMsgSplitScreenUser): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSplitScreenUser;
+};
+export declare const CNETMsgTick: {
+    encode(message: GeneratedTypescript.CNETMsgTick): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgTick;
+};
+export declare const CNETMsgStringCmd: {
+    encode(message: GeneratedTypescript.CNETMsgStringCmd): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgStringCmd;
+};
+export declare const CNETMsgSetConVar: {
+    encode(message: GeneratedTypescript.CNETMsgSetConVar): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSetConVar;
+};
+export declare const CNETMsgSignonState: {
+    encode(message: GeneratedTypescript.CNETMsgSignonState): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSignonState;
+};
+export declare const CSVCMsgGameEvent: {
+    encode(message: GeneratedTypescript.CSVCMsgGameEvent): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSVCMsgGameEvent;
+};
+export declare const CSVCMsgGameEvent_keyT: {
+    encode(message: GeneratedTypescript.CSVCMsgGameEvent_keyT): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSVCMsgGameEvent_keyT;
+};
+export declare const CSVCMsgListGameEvents: {
+    encode(message: GeneratedTypescript.CSVCMsgListGameEvents): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSVCMsgListGameEvents;
+};
+export declare const CSVCMsgListGameEvents_eventT: {
+    encode(message: GeneratedTypescript.CSVCMsgListGameEvents_eventT): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSVCMsgListGameEvents_eventT;
+};
+export declare const CNETMsgSpawnGroupLoad: {
+    encode(message: GeneratedTypescript.CNETMsgSpawnGroupLoad): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSpawnGroupLoad;
+};
+export declare const CNETMsgSpawnGroupManifestUpdate: {
+    encode(message: GeneratedTypescript.CNETMsgSpawnGroupManifestUpdate): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSpawnGroupManifestUpdate;
+};
+export declare const CNETMsgSpawnGroupSetCreationTick: {
+    encode(message: GeneratedTypescript.CNETMsgSpawnGroupSetCreationTick): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSpawnGroupSetCreationTick;
+};
+export declare const CNETMsgSpawnGroupUnload: {
+    encode(message: GeneratedTypescript.CNETMsgSpawnGroupUnload): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSpawnGroupUnload;
+};
+export declare const CNETMsgSpawnGroupLoadCompleted: {
+    encode(message: GeneratedTypescript.CNETMsgSpawnGroupLoadCompleted): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgSpawnGroupLoadCompleted;
+};
+export declare const CSVCMsgGameSessionConfiguration: {
+    encode(message: GeneratedTypescript.CSVCMsgGameSessionConfiguration): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSVCMsgGameSessionConfiguration;
+};
+export declare const CNETMsgDebugOverlay: {
+    encode(message: GeneratedTypescript.CNETMsgDebugOverlay): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CNETMsgDebugOverlay;
+};

package/.dist/generated/networkbasetypes.wrapper.js

@@ -0,0 +1,223 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: networkbasetypes.ts
+/* eslint-disable */
+export * from "./networkbasetypes.js";
+import * as GeneratedTypescript from "./networkbasetypes.js";
+export const CMsgVector = {
+    encode(message) {
+        return GeneratedTypescript.CMsgVector.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgVector.decode(input);
+    },
+};
+export const CMsgVector2D = {
+    encode(message) {
+        return GeneratedTypescript.CMsgVector2D.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgVector2D.decode(input);
+    },
+};
+export const CMsgQAngle = {
+    encode(message) {
+        return GeneratedTypescript.CMsgQAngle.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgQAngle.decode(input);
+    },
+};
+export const CMsgQuaternion = {
+    encode(message) {
+        return GeneratedTypescript.CMsgQuaternion.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgQuaternion.decode(input);
+    },
+};
+export const CMsgTransform = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTransform.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTransform.decode(input);
+    },
+};
+export const CMsgRGBA = {
+    encode(message) {
+        return GeneratedTypescript.CMsgRGBA.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgRGBA.decode(input);
+    },
+};
+export const CMsgPlayerInfo = {
+    encode(message) {
+        return GeneratedTypescript.CMsgPlayerInfo.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgPlayerInfo.decode(input);
+    },
+};
+export const CEntityMsg = {
+    encode(message) {
+        return GeneratedTypescript.CEntityMsg.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CEntityMsg.decode(input);
+    },
+};
+export const CMsgCVars = {
+    encode(message) {
+        return GeneratedTypescript.CMsgCVars.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgCVars.decode(input);
+    },
+};
+export const CMsgCVars_CVar = {
+    encode(message) {
+        return GeneratedTypescript.CMsgCVars_CVar.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgCVars_CVar.decode(input);
+    },
+};
+export const CNETMsgNOP = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgNOP.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgNOP.decode(input);
+    },
+};
+export const CNETMsgSplitScreenUser = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSplitScreenUser.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSplitScreenUser.decode(input);
+    },
+};
+export const CNETMsgTick = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgTick.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgTick.decode(input);
+    },
+};
+export const CNETMsgStringCmd = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgStringCmd.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgStringCmd.decode(input);
+    },
+};
+export const CNETMsgSetConVar = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSetConVar.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSetConVar.decode(input);
+    },
+};
+export const CNETMsgSignonState = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSignonState.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSignonState.decode(input);
+    },
+};
+export const CSVCMsgGameEvent = {
+    encode(message) {
+        return GeneratedTypescript.CSVCMsgGameEvent.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSVCMsgGameEvent.decode(input);
+    },
+};
+export const CSVCMsgGameEvent_keyT = {
+    encode(message) {
+        return GeneratedTypescript.CSVCMsgGameEvent_keyT.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSVCMsgGameEvent_keyT.decode(input);
+    },
+};
+export const CSVCMsgListGameEvents = {
+    encode(message) {
+        return GeneratedTypescript.CSVCMsgListGameEvents.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSVCMsgListGameEvents.decode(input);
+    },
+};
+export const CSVCMsgListGameEvents_eventT = {
+    encode(message) {
+        return GeneratedTypescript.CSVCMsgListGameEvents_eventT.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSVCMsgListGameEvents_eventT.decode(input);
+    },
+};
+export const CNETMsgSpawnGroupLoad = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSpawnGroupLoad.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSpawnGroupLoad.decode(input);
+    },
+};
+export const CNETMsgSpawnGroupManifestUpdate = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSpawnGroupManifestUpdate.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSpawnGroupManifestUpdate.decode(input);
+    },
+};
+export const CNETMsgSpawnGroupSetCreationTick = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSpawnGroupSetCreationTick.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSpawnGroupSetCreationTick.decode(input);
+    },
+};
+export const CNETMsgSpawnGroupUnload = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSpawnGroupUnload.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSpawnGroupUnload.decode(input);
+    },
+};
+export const CNETMsgSpawnGroupLoadCompleted = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgSpawnGroupLoadCompleted.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgSpawnGroupLoadCompleted.decode(input);
+    },
+};
+export const CSVCMsgGameSessionConfiguration = {
+    encode(message) {
+        return GeneratedTypescript.CSVCMsgGameSessionConfiguration.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSVCMsgGameSessionConfiguration.decode(input);
+    },
+};
+export const CNETMsgDebugOverlay = {
+    encode(message) {
+        return GeneratedTypescript.CNETMsgDebugOverlay.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CNETMsgDebugOverlay.decode(input);
+    },
+};

package/.dist/generated/networksystem_protomessages.d.ts

@@ -0,0 +1,26 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export interface NetMessageSplitscreenUserChanged {
+    slot?: number | undefined;
+}
+export interface NetMessageConnectionClosed {
+    reason?: number | undefined;
+    message?: string | undefined;
+}
+export interface NetMessageConnectionCrashed {
+    reason?: number | undefined;
+    message?: string | undefined;
+}
+export interface NetMessagePacketStart {
+}
+export interface NetMessagePacketEnd {
+}
+export declare const NetMessageSplitscreenUserChanged: MessageFns<NetMessageSplitscreenUserChanged>;
+export declare const NetMessageConnectionClosed: MessageFns<NetMessageConnectionClosed>;
+export declare const NetMessageConnectionCrashed: MessageFns<NetMessageConnectionCrashed>;
+export declare const NetMessagePacketStart: MessageFns<NetMessagePacketStart>;
+export declare const NetMessagePacketEnd: MessageFns<NetMessagePacketEnd>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};

package/.dist/generated/networksystem_protomessages.js

@@ -0,0 +1,172 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: networksystem_protomessages.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+function createBaseNetMessageSplitscreenUserChanged() {
+    return { slot: 0 };
+}
+export const NetMessageSplitscreenUserChanged = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.slot !== undefined && message.slot !== 0) {
+            writer.uint32(8).uint32(message.slot);
+        }
+        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 = createBaseNetMessageSplitscreenUserChanged();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.slot = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseNetMessageConnectionClosed() {
+    return { reason: 0, message: "" };
+}
+export const NetMessageConnectionClosed = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.reason !== undefined && message.reason !== 0) {
+            writer.uint32(8).uint32(message.reason);
+        }
+        if (message.message !== undefined && message.message !== "") {
+            writer.uint32(18).string(message.message);
+        }
+        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 = createBaseNetMessageConnectionClosed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.reason = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseNetMessageConnectionCrashed() {
+    return { reason: 0, message: "" };
+}
+export const NetMessageConnectionCrashed = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.reason !== undefined && message.reason !== 0) {
+            writer.uint32(8).uint32(message.reason);
+        }
+        if (message.message !== undefined && message.message !== "") {
+            writer.uint32(18).string(message.message);
+        }
+        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 = createBaseNetMessageConnectionCrashed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.reason = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseNetMessagePacketStart() {
+    return {};
+}
+export const NetMessagePacketStart = {
+    encode(_, writer = new BinaryWriter()) {
+        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 = createBaseNetMessagePacketStart();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseNetMessagePacketEnd() {
+    return {};
+}
+export const NetMessagePacketEnd = {
+    encode(_, writer = new BinaryWriter()) {
+        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 = createBaseNetMessagePacketEnd();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};

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

@@ -0,0 +1,22 @@
+export * from "./networksystem_protomessages.js";
+import * as GeneratedTypescript from "./networksystem_protomessages.js";
+export declare const NetMessageSplitscreenUserChanged: {
+    encode(message: GeneratedTypescript.NetMessageSplitscreenUserChanged): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.NetMessageSplitscreenUserChanged;
+};
+export declare const NetMessageConnectionClosed: {
+    encode(message: GeneratedTypescript.NetMessageConnectionClosed): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.NetMessageConnectionClosed;
+};
+export declare const NetMessageConnectionCrashed: {
+    encode(message: GeneratedTypescript.NetMessageConnectionCrashed): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.NetMessageConnectionCrashed;
+};
+export declare const NetMessagePacketStart: {
+    encode(message: GeneratedTypescript.NetMessagePacketStart): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.NetMessagePacketStart;
+};
+export declare const NetMessagePacketEnd: {
+    encode(message: GeneratedTypescript.NetMessagePacketEnd): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.NetMessagePacketEnd;
+};

package/.dist/generated/networksystem_protomessages.wrapper.js

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

package/.dist/generated/prediction_events.d.ts

@@ -0,0 +1,30 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+export declare enum EBasePredictionEvents {
+    BPE_StringCommand = 128,
+    BPE_Teleport = 130,
+    BPE_Diagnostic = 16384,
+    UNRECOGNIZED = -1
+}
+export interface CPredictionEventTeleport {
+    origin?: CMsgVector | undefined;
+    angles?: CMsgQAngle | undefined;
+    dropToGroundRange?: number | undefined;
+}
+export interface CPredictionEventStringCommand {
+    command?: string | undefined;
+}
+export interface CPredictionEventDiagnostic {
+    id?: number | undefined;
+    requestedSync?: number | undefined;
+    requestedPlayerIndex?: number | undefined;
+    executionSync: number[];
+}
+export declare const CPredictionEventTeleport: MessageFns<CPredictionEventTeleport>;
+export declare const CPredictionEventStringCommand: MessageFns<CPredictionEventStringCommand>;
+export declare const CPredictionEventDiagnostic: MessageFns<CPredictionEventDiagnostic>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};