cs2-protobuf 1.0.1

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

@@ -0,0 +1,102 @@
+export * from "./te.js";
+import * as GeneratedTypescript from "./te.js";
+export declare const CMsgTEArmorRicochet: {
+    encode(message: GeneratedTypescript.CMsgTEArmorRicochet): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEArmorRicochet;
+};
+export declare const CMsgTEBaseBeam: {
+    encode(message: GeneratedTypescript.CMsgTEBaseBeam): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBaseBeam;
+};
+export declare const CMsgTEBeamEntPoint: {
+    encode(message: GeneratedTypescript.CMsgTEBeamEntPoint): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBeamEntPoint;
+};
+export declare const CMsgTEBeamEnts: {
+    encode(message: GeneratedTypescript.CMsgTEBeamEnts): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBeamEnts;
+};
+export declare const CMsgTEBeamPoints: {
+    encode(message: GeneratedTypescript.CMsgTEBeamPoints): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBeamPoints;
+};
+export declare const CMsgTEBeamRing: {
+    encode(message: GeneratedTypescript.CMsgTEBeamRing): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBeamRing;
+};
+export declare const CMsgTEBubbles: {
+    encode(message: GeneratedTypescript.CMsgTEBubbles): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBubbles;
+};
+export declare const CMsgTEBubbleTrail: {
+    encode(message: GeneratedTypescript.CMsgTEBubbleTrail): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBubbleTrail;
+};
+export declare const CMsgTEDecal: {
+    encode(message: GeneratedTypescript.CMsgTEDecal): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEDecal;
+};
+export declare const CMsgEffectData: {
+    encode(message: GeneratedTypescript.CMsgEffectData): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgEffectData;
+};
+export declare const CMsgTEEffectDispatch: {
+    encode(message: GeneratedTypescript.CMsgTEEffectDispatch): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEEffectDispatch;
+};
+export declare const CMsgTEEnergySplash: {
+    encode(message: GeneratedTypescript.CMsgTEEnergySplash): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEEnergySplash;
+};
+export declare const CMsgTEFizz: {
+    encode(message: GeneratedTypescript.CMsgTEFizz): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEFizz;
+};
+export declare const CMsgTEShatterSurface: {
+    encode(message: GeneratedTypescript.CMsgTEShatterSurface): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEShatterSurface;
+};
+export declare const CMsgTEGlowSprite: {
+    encode(message: GeneratedTypescript.CMsgTEGlowSprite): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEGlowSprite;
+};
+export declare const CMsgTEImpact: {
+    encode(message: GeneratedTypescript.CMsgTEImpact): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEImpact;
+};
+export declare const CMsgTEMuzzleFlash: {
+    encode(message: GeneratedTypescript.CMsgTEMuzzleFlash): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEMuzzleFlash;
+};
+export declare const CMsgTEBloodStream: {
+    encode(message: GeneratedTypescript.CMsgTEBloodStream): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEBloodStream;
+};
+export declare const CMsgTEExplosion: {
+    encode(message: GeneratedTypescript.CMsgTEExplosion): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEExplosion;
+};
+export declare const CMsgTEDust: {
+    encode(message: GeneratedTypescript.CMsgTEDust): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEDust;
+};
+export declare const CMsgTELargeFunnel: {
+    encode(message: GeneratedTypescript.CMsgTELargeFunnel): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTELargeFunnel;
+};
+export declare const CMsgTESparks: {
+    encode(message: GeneratedTypescript.CMsgTESparks): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTESparks;
+};
+export declare const CMsgTEPhysicsProp: {
+    encode(message: GeneratedTypescript.CMsgTEPhysicsProp): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEPhysicsProp;
+};
+export declare const CMsgTESmoke: {
+    encode(message: GeneratedTypescript.CMsgTESmoke): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTESmoke;
+};
+export declare const CMsgTEWorldDecal: {
+    encode(message: GeneratedTypescript.CMsgTEWorldDecal): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEWorldDecal;
+};

package/.dist/generated/te.wrapper.js

@@ -0,0 +1,207 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: te.ts
+/* eslint-disable */
+export * from "./te.js";
+import * as GeneratedTypescript from "./te.js";
+export const CMsgTEArmorRicochet = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEArmorRicochet.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEArmorRicochet.decode(input);
+    },
+};
+export const CMsgTEBaseBeam = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBaseBeam.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBaseBeam.decode(input);
+    },
+};
+export const CMsgTEBeamEntPoint = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBeamEntPoint.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBeamEntPoint.decode(input);
+    },
+};
+export const CMsgTEBeamEnts = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBeamEnts.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBeamEnts.decode(input);
+    },
+};
+export const CMsgTEBeamPoints = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBeamPoints.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBeamPoints.decode(input);
+    },
+};
+export const CMsgTEBeamRing = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBeamRing.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBeamRing.decode(input);
+    },
+};
+export const CMsgTEBubbles = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBubbles.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBubbles.decode(input);
+    },
+};
+export const CMsgTEBubbleTrail = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBubbleTrail.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBubbleTrail.decode(input);
+    },
+};
+export const CMsgTEDecal = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEDecal.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEDecal.decode(input);
+    },
+};
+export const CMsgEffectData = {
+    encode(message) {
+        return GeneratedTypescript.CMsgEffectData.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgEffectData.decode(input);
+    },
+};
+export const CMsgTEEffectDispatch = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEEffectDispatch.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEEffectDispatch.decode(input);
+    },
+};
+export const CMsgTEEnergySplash = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEEnergySplash.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEEnergySplash.decode(input);
+    },
+};
+export const CMsgTEFizz = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEFizz.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEFizz.decode(input);
+    },
+};
+export const CMsgTEShatterSurface = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEShatterSurface.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEShatterSurface.decode(input);
+    },
+};
+export const CMsgTEGlowSprite = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEGlowSprite.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEGlowSprite.decode(input);
+    },
+};
+export const CMsgTEImpact = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEImpact.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEImpact.decode(input);
+    },
+};
+export const CMsgTEMuzzleFlash = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEMuzzleFlash.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEMuzzleFlash.decode(input);
+    },
+};
+export const CMsgTEBloodStream = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEBloodStream.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEBloodStream.decode(input);
+    },
+};
+export const CMsgTEExplosion = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEExplosion.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEExplosion.decode(input);
+    },
+};
+export const CMsgTEDust = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEDust.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEDust.decode(input);
+    },
+};
+export const CMsgTELargeFunnel = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTELargeFunnel.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTELargeFunnel.decode(input);
+    },
+};
+export const CMsgTESparks = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTESparks.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTESparks.decode(input);
+    },
+};
+export const CMsgTEPhysicsProp = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEPhysicsProp.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEPhysicsProp.decode(input);
+    },
+};
+export const CMsgTESmoke = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTESmoke.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTESmoke.decode(input);
+    },
+};
+export const CMsgTEWorldDecal = {
+    encode(message) {
+        return GeneratedTypescript.CMsgTEWorldDecal.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CMsgTEWorldDecal.decode(input);
+    },
+};

package/.dist/generated/uifontfile_format.d.ts

@@ -0,0 +1,20 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export interface CUIFontFilePB {
+    fontFileName?: string | undefined;
+    opentypeFontData?: Uint8Array | undefined;
+}
+export interface CUIFontFilePackagePB {
+    packageVersion?: number | undefined;
+    encryptedFontFiles: CUIFontFilePackagePB_CUIEncryptedFontFilePB[];
+}
+export interface CUIFontFilePackagePB_CUIEncryptedFontFilePB {
+    encryptedContents?: Uint8Array | undefined;
+}
+export declare const CUIFontFilePB: MessageFns<CUIFontFilePB>;
+export declare const CUIFontFilePackagePB: MessageFns<CUIFontFilePackagePB>;
+export declare const CUIFontFilePackagePB_CUIEncryptedFontFilePB: MessageFns<CUIFontFilePackagePB_CUIEncryptedFontFilePB>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};

package/.dist/generated/uifontfile_format.js

@@ -0,0 +1,126 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: uifontfile_format.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+function createBaseCUIFontFilePB() {
+    return { fontFileName: "", opentypeFontData: new Uint8Array(0) };
+}
+export const CUIFontFilePB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.fontFileName !== undefined && message.fontFileName !== "") {
+            writer.uint32(10).string(message.fontFileName);
+        }
+        if (message.opentypeFontData !== undefined && message.opentypeFontData.length !== 0) {
+            writer.uint32(18).bytes(message.opentypeFontData);
+        }
+        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 = createBaseCUIFontFilePB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fontFileName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.opentypeFontData = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCUIFontFilePackagePB() {
+    return { packageVersion: 0, encryptedFontFiles: [] };
+}
+export const CUIFontFilePackagePB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.packageVersion !== undefined && message.packageVersion !== 0) {
+            writer.uint32(8).uint32(message.packageVersion);
+        }
+        for (const v of message.encryptedFontFiles) {
+            CUIFontFilePackagePB_CUIEncryptedFontFilePB.encode(v, writer.uint32(18).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 = createBaseCUIFontFilePackagePB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.packageVersion = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.encryptedFontFiles.push(CUIFontFilePackagePB_CUIEncryptedFontFilePB.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCUIFontFilePackagePB_CUIEncryptedFontFilePB() {
+    return { encryptedContents: new Uint8Array(0) };
+}
+export const CUIFontFilePackagePB_CUIEncryptedFontFilePB = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.encryptedContents !== undefined && message.encryptedContents.length !== 0) {
+            writer.uint32(10).bytes(message.encryptedContents);
+        }
+        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 = createBaseCUIFontFilePackagePB_CUIEncryptedFontFilePB();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.encryptedContents = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};

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

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

package/.dist/generated/uifontfile_format.wrapper.js

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

package/.dist/generated/usercmd.d.ts

@@ -0,0 +1,53 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle } from "./networkbasetypes.js";
+export interface CInButtonStatePB {
+    buttonstate1?: number | undefined;
+    buttonstate2?: number | undefined;
+    buttonstate3?: number | undefined;
+}
+export interface CSubtickMoveStep {
+    button?: number | undefined;
+    pressed?: boolean | undefined;
+    when?: number | undefined;
+    analogForwardDelta?: number | undefined;
+    analogLeftDelta?: number | undefined;
+    pitchDelta?: number | undefined;
+    yawDelta?: number | undefined;
+}
+export interface CBaseUserCmdExecutionNotes {
+    ignoredReason?: string | undefined;
+}
+export interface CBaseUserCmdPB {
+    legacyCommandNumber?: number | undefined;
+    clientTick?: number | undefined;
+    predictionOffsetTicksX256?: number | undefined;
+    buttonsPb?: CInButtonStatePB | undefined;
+    viewangles?: CMsgQAngle | undefined;
+    forwardmove?: number | undefined;
+    leftmove?: number | undefined;
+    upmove?: number | undefined;
+    impulse?: number | undefined;
+    weaponselect?: number | undefined;
+    randomSeed?: number | undefined;
+    mousedx?: number | undefined;
+    mousedy?: number | undefined;
+    pawnEntityHandle?: number | undefined;
+    subtickMoves: CSubtickMoveStep[];
+    moveCrc?: Uint8Array | undefined;
+    consumedServerAngleChanges?: number | undefined;
+    cmdFlags?: number | undefined;
+    executionNotes?: CBaseUserCmdExecutionNotes | undefined;
+}
+export interface CUserCmdBasePB {
+    base?: CBaseUserCmdPB | undefined;
+}
+export declare const CInButtonStatePB: MessageFns<CInButtonStatePB>;
+export declare const CSubtickMoveStep: MessageFns<CSubtickMoveStep>;
+export declare const CBaseUserCmdExecutionNotes: MessageFns<CBaseUserCmdExecutionNotes>;
+export declare const CBaseUserCmdPB: MessageFns<CBaseUserCmdPB>;
+export declare const CUserCmdBasePB: MessageFns<CUserCmdBasePB>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};