rock-mod 0.1.0 → 0.2.0

package/dist/server/entities/ragemp/player/RagePlayer.js

@@ -2,13 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayer = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
-const RagePlayerNetManager_1 = require("./RagePlayerNetManager");
 const RockMod_1 = require("../../../RockMod");
 class RagePlayer extends RageEntity_1.RageEntity {
-    _net;
-    get net() {
-        return this._net;
-    }
     get name() {
         return this.mpEntity.name;
     }
@@ -56,12 +51,14 @@ class RagePlayer extends RageEntity_1.RageEntity {
         }
         return players;
     }
-    get isExists() {
-        return mp.players.exists(this.mpEntity);
-    }
     constructor(options) {
         super(options);
-        this._net = new RagePlayerNetManager_1.RagePlayerNetManager(this.mpEntity);
+    }
+    emitEvent(eventName, ...args) {
+        return RockMod_1.RockMod.instance.net.events.emitClient(this, eventName, ...args);
+    }
+    emitRPC(rpcName, ...args) {
+        return RockMod_1.RockMod.instance.net.rpc.emitClient(this, rpcName, ...args);
     }
     spawn(position) {
         return this.mpEntity.spawn(new mp.Vector3(position));

package/dist/server/entities/ragemp/player/RagePlayersManager.js

@@ -45,6 +45,7 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         const net = RockMod_1.RockMod.instance.net;
         net.events.on({
             playerJoin: (mpPlayer) => {
+                mpPlayer.isExists = () => mp.players.exists(mpPlayer);
                 const player = new RagePlayer_1.RagePlayer({
                     mpEntity: mpPlayer,
                 });

package/dist/server/entities/ragemp/vehicle/RageVehicle.d.ts

@@ -1,9 +1,30 @@
 import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
 import { IVehicle } from "../../common/vehicle/IVehicle";
+import { RGBA } from "../../../common/utils";
+import { RagePlayer } from "../player/RagePlayer";
 export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
 }
 export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehicle {
     get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): RGBA;
+    get customSecondaryColor(): RGBA;
+    get driver(): RagePlayer | null;
+    get passengers(): Set<RagePlayer>;
     constructor(options: IRageVehicleOptions);
     setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
+    setLocked(value: boolean): void;
+    setPrimaryColor(value: number): void;
+    setSecondaryColor(value: number): void;
+    setCustomPrimaryColor(value: RGBA): void;
+    setCustomSecondaryColor(value: RGBA): void;
+    explode(): void;
+    repair(): void;
 }

package/dist/server/entities/ragemp/vehicle/RageVehicle.js

@@ -2,15 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehicle = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
+const utils_1 = require("../../../common/utils");
+const RockMod_1 = require("../../../RockMod");
 class RageVehicle extends RageEntity_1.RageEntity {
     get bodyHealth() {
         return this.mpEntity.bodyHealth;
     }
+    get engineHealth() {
+        return this.mpEntity.engineHealth;
+    }
+    get numberPlate() {
+        return this.mpEntity.numberPlate;
+    }
+    get isLocked() {
+        return this.mpEntity.locked;
+    }
+    get isDead() {
+        return this.mpEntity.dead;
+    }
+    get primaryColor() {
+        return this.mpEntity.getColor(0);
+    }
+    get secondaryColor() {
+        return this.mpEntity.getColor(1);
+    }
+    get customPrimaryColor() {
+        const [r, g, b] = this.mpEntity.getColorRGB(0);
+        return new utils_1.RGBA(r, g, b);
+    }
+    get customSecondaryColor() {
+        const [r, g, b] = this.mpEntity.getColorRGB(1);
+        return new utils_1.RGBA(r, g, b);
+    }
+    get driver() {
+        const mpPlayer = this.mpEntity.getOccupant(0);
+        if (!mpPlayer) {
+            return null;
+        }
+        return RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+    }
+    get passengers() {
+        const players = new Set();
+        for (const mpPlayer of this.mpEntity.getOccupants()) {
+            const player = RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+            players.add(player);
+        }
+        return players;
+    }
     constructor(options) {
         super(options);
     }
     setBodyHealth(value) {
         this.mpEntity.bodyHealth = value;
     }
+    setEngineHealth(value) {
+        throw new Error(`Not implemented (setEngineHealth: ${value})`);
+    }
+    setNumberPlate(value) {
+        this.mpEntity.numberPlate = value;
+    }
+    setLocked(value) {
+        this.mpEntity.locked = value;
+    }
+    setPrimaryColor(value) {
+        return this.mpEntity.setColor(value, this.secondaryColor);
+    }
+    setSecondaryColor(value) {
+        return this.mpEntity.setColor(this.primaryColor, value);
+    }
+    setCustomPrimaryColor(value) {
+        this.mpEntity.setColorRGB(value.r, value.g, value.b, this.customSecondaryColor.r, this.customSecondaryColor.g, this.customSecondaryColor.b);
+    }
+    setCustomSecondaryColor(value) {
+        this.mpEntity.setColorRGB(this.customPrimaryColor.r, this.customPrimaryColor.g, this.customPrimaryColor.b, value.r, value.g, value.b);
+    }
+    explode() {
+        return this.mpEntity.explode();
+    }
+    repair() {
+        return this.mpEntity.repair();
+    }
 }
 exports.RageVehicle = RageVehicle;

package/dist/server/entities/ragemp/vehicle/RageVehiclesManager.js

@@ -10,8 +10,14 @@ class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
         });
     }
     create(options) {
-        const { model, position } = options;
-        const mpEntity = mp.vehicles.new(model, new mp.Vector3(position));
+        const { model, position, dimension, rotation, engine, locked } = options;
+        const mpEntity = mp.vehicles.new(model, new mp.Vector3(position), {
+            dimension,
+            heading: rotation.z,
+            engine,
+            locked,
+        });
+        mpEntity.rotation = new mp.Vector3(rotation);
         const vehicle = new RageVehicle_1.RageVehicle({ mpEntity });
         this.registerBaseObject(vehicle);
         return vehicle;

package/dist/server/entities/ragemp/worldObject/RageWorldObject.js

@@ -15,7 +15,7 @@ class RageWorldObject extends RageBaseObject_1.RageBaseObject {
         super(options);
     }
     setPosition(value) {
-        this.mpEntity.position = new Vector3(value);
+        this.mpEntity.position = new mp.Vector3(value);
     }
     setDimension(value) {
         this.mpEntity.dimension = value;

package/dist/server/net/altv/events/AltVEventsManager.d.ts

@@ -1,16 +1,16 @@
-import { IEventsManager, INetServerEvents } from "../../common/events/IEventsManager";
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
 import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
 import alt = AltVServer;
 import { AltVBaseObject } from "../../../entities/altv/baseObject/AltVBaseObject";
-interface IAltVServerEvent extends alt.IServerEvent, INetServerEvents {
+export interface IAltVServerEvents extends alt.IServerEvent, INetServerEvents {
     "rm::entityCreated"(baseObject: AltVBaseObject<alt.BaseObject>): void;
     "rm::entityDestroyed"(baseObject: AltVBaseObject<alt.BaseObject>): void;
 }
+export interface IAltVClientEvents extends INetClientEvents {
+}
 export declare class AltVEventsManager implements IEventsManager {
-    on<K extends keyof IAltVServerEvent>(events: Record<K, (...args: Parameters<IAltVServerEvent[K]>) => void>): void;
-    onServer<K extends keyof IAltVServerEvent>(events: Record<K, (...args: Parameters<IAltVServerEvent[K]>) => void>): void;
-    off(eventName: keyof IAltVServerEvent, listener: (...args: unknown[]) => void): void;
-    emit(eventName: keyof IAltVServerEvent, ...args: unknown[]): void;
-    emitClient(player: AltVPlayer, eventName: keyof IAltVServerEvent, ...args: unknown[]): void;
+    on<K extends keyof IAltVServerEvents>(events: Record<K, (...args: Parameters<IAltVServerEvents[K]>) => void>): void;
+    off<K extends keyof IAltVServerEvents>(eventName: K, listener: (...args: Parameters<IAltVServerEvents[K]>) => void): void;
+    emit<K extends keyof IAltVServerEvents>(eventName: K, ...args: Parameters<IAltVServerEvents[K]>): void;
+    emitClient<K extends keyof IAltVClientEvents>(player: AltVPlayer, eventName: K, ...args: Parameters<IAltVClientEvents[K]>): void;
 }
-export {};

package/dist/server/net/altv/events/AltVEventsManager.js

@@ -2,17 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVEventsManager = void 0;
 var alt = AltVServer;
+var Player = AltVServer.Player;
 class AltVEventsManager {
     on(events) {
         for (const eventName of Object.keys(events)) {
             alt.on(eventName, events[eventName]);
         }
     }
-    onServer(events) {
-        for (const eventName of Object.keys(events)) {
-            alt.on(eventName, events[eventName]);
-        }
-    }
     off(eventName, listener) {
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
@@ -22,7 +18,11 @@ class AltVEventsManager {
         return alt.emit(eventName, ...args);
     }
     emitClient(player, eventName, ...args) {
-        return player.net.callEvent(eventName, ...args);
+        const mpPlayer = Player.getByID(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.emit(eventName, ...args);
     }
 }
 exports.AltVEventsManager = AltVEventsManager;

package/dist/server/net/altv/rpc/AltVRPCManager.d.ts

@@ -1,11 +1,12 @@
-import { IRPCManager } from "../../common/rpc/IRPCManager";
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
 import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
 import shared = AltVShared;
-interface IAltVRPCName extends shared.ICustomClientServerRpc {
+export interface IAltVServerRPC extends shared.ICustomClientServerRpc, INetServerRPC {
+}
+export interface IAltVClientRPC extends shared.ICustomServerClientRpc, INetClientRPC {
 }
 export declare class AltVRPCManager implements IRPCManager {
-    register(rpcName: keyof IAltVRPCName, handler: (player: AltVPlayer, ...args: unknown[]) => unknown): void;
-    unregister(rpcName: string): void;
-    callClient(player: AltVPlayer, rpcName: string, ...args: unknown[]): Promise<unknown>;
+    register<K extends keyof IAltVServerRPC>(rpcName: K, handler: (player: AltVPlayer, ...args: Parameters<IAltVServerRPC[K]>) => ReturnType<IAltVServerRPC[K]>): void;
+    unregister<K extends keyof IAltVServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IAltVClientRPC>(player: AltVPlayer, rpcName: K, ...args: Parameters<IAltVClientRPC[K]>): Promise<ReturnType<IAltVClientRPC[K]>>;
 }
-export {};

package/dist/server/net/altv/rpc/AltVRPCManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVRPCManager = void 0;
 var alt = AltVServer;
+var Player = AltVServer.Player;
 class AltVRPCManager {
     register(rpcName, handler) {
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -11,8 +12,12 @@ class AltVRPCManager {
     unregister(rpcName) {
         return alt.offRpc(rpcName);
     }
-    callClient(player, rpcName, ...args) {
-        return player.net.callRPC(rpcName, ...args);
+    emitClient(player, rpcName, ...args) {
+        const mpPlayer = Player.getByID(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.emitRpc(rpcName, ...args);
     }
 }
 exports.AltVRPCManager = AltVRPCManager;

package/dist/server/net/common/events/IEventsManager.d.ts

@@ -6,10 +6,11 @@ export interface INetServerEvents {
     "rm::entityCreated"(entity: IBaseObject): void;
     "rm::entityDestroyed"(entity: IBaseObject): void;
 }
+export interface INetClientEvents {
+}
 export interface IEventsManager {
     on<K extends keyof INetServerEvents>(events: Record<K, (...args: Parameters<INetServerEvents[K]>) => void>): void;
-    onServer<K extends keyof INetServerEvents>(events: Record<K, (...args: Parameters<INetServerEvents[K]>) => void>): void;
-    off(eventName: string, listener: (...args: unknown[]) => void): void;
-    emit(eventName: string, ...args: unknown[]): void;
-    emitClient(player: IPlayer, eventName: string, ...args: unknown[]): void;
+    off<K extends keyof INetServerEvents>(eventName: K, listener: (...args: Parameters<INetServerEvents[K]>) => void): void;
+    emit<K extends keyof INetServerEvents>(eventName: K, ...args: Parameters<INetServerEvents[K]>): void;
+    emitClient<K extends keyof INetClientEvents>(player: IPlayer, eventName: K, ...args: Parameters<INetClientEvents[K]>): void;
 }

package/dist/server/net/common/rpc/IRPCManager.d.ts

@@ -1,6 +1,10 @@
 import { IPlayer } from "../../../entities/common/player/IPlayer";
+export interface INetServerRPC {
+}
+export interface INetClientRPC {
+}
 export interface IRPCManager {
-    register(rpcName: string, handler: (player: IPlayer, ...args: unknown[]) => unknown): void;
-    unregister(rpcName: string): void;
-    callClient(player: IPlayer, rpcName: string, ...args: unknown[]): Promise<unknown>;
+    register<K extends keyof INetServerRPC>(rpcName: K, handler: (player: IPlayer, ...args: Parameters<INetServerRPC[K]>) => ReturnType<INetServerRPC[K]>): void;
+    unregister<K extends keyof INetServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof INetClientRPC>(player: IPlayer, rpcName: K, ...args: Parameters<INetClientRPC[K]>): Promise<ReturnType<INetClientRPC[K]>>;
 }

package/dist/server/net/ragemp/events/RageEventsManager.d.ts

@@ -1,7 +1,7 @@
-import { IEventsManager, INetServerEvents } from "../../common/events/IEventsManager";
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
 import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
 import { RageBaseObject } from "../../../entities/ragemp/baseObject/RageBaseObject";
-interface RageServerEvents extends IServerEvents, INetServerEvents {
+export interface IRageServerEvents extends IServerEvents, INetServerEvents {
     "rm::playerConnected"(player: RagePlayer): void;
     "rm::playerDisconnected"(player: RagePlayer): void;
     "rm::entityCreated"(entity: RageBaseObject): void;
@@ -9,11 +9,11 @@ interface RageServerEvents extends IServerEvents, INetServerEvents {
     playerJoin(player: PlayerMp): void;
     playerQuit(player: PlayerMp): void;
 }
+export interface IRageClientEvents extends INetClientEvents {
+}
 export declare class RageEventsManager implements IEventsManager {
-    on<K extends keyof RageServerEvents>(events: Record<K, (...args: Parameters<RageServerEvents[K]>) => void>): void;
-    onServer<K extends keyof RageServerEvents>(events: Record<K, (...args: Parameters<RageServerEvents[K]>) => void>): void;
-    off(eventName: keyof RageServerEvents, listener: (...args: unknown[]) => void): void;
-    emit(eventName: keyof RageServerEvents, ...args: unknown[]): void;
-    emitClient(player: RagePlayer, eventName: keyof RageServerEvents, ...args: unknown[]): void;
+    on<K extends keyof IRageServerEvents>(events: Record<K, (...args: Parameters<IRageServerEvents[K]>) => void>): void;
+    off<K extends keyof IRageServerEvents>(eventName: K, listener: (...args: Parameters<IRageServerEvents[K]>) => void): void;
+    emit<K extends keyof IRageServerEvents>(eventName: K, ...args: Parameters<IRageServerEvents[K]>): void;
+    emitClient<K extends keyof IRageClientEvents>(player: RagePlayer, eventName: K, ...args: Parameters<IRageClientEvents[K]>): void;
 }
-export {};

package/dist/server/net/ragemp/events/RageEventsManager.js

@@ -7,19 +7,18 @@ class RageEventsManager {
             mp.events.add(eventName, events[eventName]);
         }
     }
-    onServer(events) {
-        for (const eventName of Object.keys(events)) {
-            mp.events.add(eventName, events[eventName]);
-        }
-    }
     off(eventName, listener) {
         return mp.events.remove(eventName, listener);
     }
     emit(eventName, ...args) {
-        return mp.events.call(eventName, args);
+        return mp.events.call(eventName, ...args);
     }
     emitClient(player, eventName, ...args) {
-        return player.net.callEvent(eventName, ...args);
+        const mpPlayer = mp.players.at(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.call(eventName, args);
     }
 }
 exports.RageEventsManager = RageEventsManager;

package/dist/server/net/ragemp/rpc/RageRPCManager.d.ts

@@ -1,7 +1,11 @@
-import { IRPCManager } from "../../common/rpc/IRPCManager";
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
 import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
+export interface IRageServerRPC extends INetServerRPC {
+}
+export interface IRageClientRPC extends INetClientRPC {
+}
 export declare class RageRPCManager implements IRPCManager {
-    register(rpcName: string, handler: (player: RagePlayer, ...args: unknown[]) => unknown): void;
-    unregister(rpcName: string): void;
-    callClient(player: RagePlayer, rpcName: string, ...args: unknown[]): Promise<unknown>;
+    register<K extends keyof IRageServerRPC>(rpcName: K, handler: (player: RagePlayer, ...args: Parameters<IRageServerRPC[K]>) => ReturnType<IRageServerRPC[K]>): void;
+    unregister<K extends keyof IRageServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IRageClientRPC>(player: RagePlayer, rpcName: K, ...args: Parameters<IRageClientRPC[K]>): Promise<ReturnType<IRageClientRPC[K]>>;
 }

package/dist/server/net/ragemp/rpc/RageRPCManager.js

@@ -8,8 +8,12 @@ class RageRPCManager {
     unregister(rpcName) {
         return mp.events.remove(rpcName);
     }
-    callClient(player, rpcName, ...args) {
-        return player.net.callRPC(rpcName, ...args);
+    emitClient(player, rpcName, ...args) {
+        const mpPlayer = mp.players.at(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.callProc(rpcName, args);
     }
 }
 exports.RageRPCManager = RageRPCManager;

package/package.json

@@ -1,59 +1,62 @@
-{
-  "name": "rock-mod",
-  "version": "0.1.0",
-  "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "start": "npx tsx src/server/index.ts",
-    "build": "npm run build:server && npm run build:client",
-    "build:server": "tsc --project src/server/tsconfig.json",
-    "build:client": "tsc --project src/client/tsconfig.json",
-    "lint:server:check": "cd src/server && eslint . --ext .ts",
-    "lint:server:fix": "cd src/server && eslint . --ext .ts --fix",
-    "lint:client:check": "cd src/client && eslint . --ext .ts",
-    "lint:client:fix": "cd src/client && eslint . --ext .ts --fix",
-    "lint:check": "npm run lint:server:check && npm run lint:client:check",
-    "lint:fix": "npm run lint:server:fix && npm run lint:client:fix",
-    "format:check": "prettier --check .",
-    "format:fix": "prettier --write .",
-    "type:server:check": "tsc --noEmit --project src/server/tsconfig.json",
-    "type:client:check": "tsc --noEmit --project src/client/tsconfig.json",
-    "type:check": "npm run type:server:check && npm run type:client:check",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "husky"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
-  "lint-staged": {
-    "*.{ts,json,md}": [
-      "npm run lint:fix",
-      "npm run format:fix"
-    ]
-  },
-  "files": [
-    "dist"
-  ],
-  "keywords": [
-    "gta"
-  ],
-  "author": "xvetal",
-  "license": "MIT",
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
-    "eslint": "^8.57.1",
-    "eslint-config-airbnb-typescript": "^18.0.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-import-resolver-typescript": "^3.6.3",
-    "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "husky": "^9.1.6",
-    "lint-staged": "^15.2.10",
-    "prettier": "^3.3.3",
-    "typescript": "^5.6.2"
-  }
-}
+{
+  "name": "rock-mod",
+  "version": "0.2.0",
+  "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "start": "npx tsx src/server/index.ts",
+    "build": "npm run build:server && npm run build:client",
+    "build:server": "tsc --project src/server/tsconfig.json",
+    "build:client": "tsc --project src/client/tsconfig.json",
+    "lint:server:check": "cd src/server && eslint . --ext .ts",
+    "lint:server:fix": "cd src/server && eslint . --ext .ts --fix",
+    "lint:client:check": "cd src/client && eslint . --ext .ts",
+    "lint:client:fix": "cd src/client && eslint . --ext .ts --fix",
+    "lint:check": "npm run lint:server:check && npm run lint:client:check",
+    "lint:fix": "npm run lint:server:fix && npm run lint:client:fix",
+    "format:check": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "type:server:check": "tsc --noEmit --project src/server/tsconfig.json",
+    "type:client:check": "tsc --noEmit --project src/client/tsconfig.json",
+    "type:check": "npm run type:server:check && npm run type:client:check",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "husky"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,json,md}": [
+      "npm run lint:fix",
+      "npm run format:fix"
+    ]
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "gta",
+    "multiplayer",
+    "altv",
+    "ragemp"
+  ],
+  "author": "xvetal",
+  "license": "MIT",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.3.3",
+    "typescript": "^5.6.2"
+  }
+}

package/dist/server/entities/altv/player/AltVPlayerNetManager.d.ts

@@ -1,8 +0,0 @@
-import { IPlayerNetManager } from "../../common/player/IPlayerNetManager";
-import Player = AltVServer.Player;
-export declare class AltVPlayerNetManager implements IPlayerNetManager {
-    private readonly _player;
-    constructor(player: Player);
-    callEvent(eventName: string, ...args: unknown[]): void;
-    callRPC(rpcName: string, ...args: unknown[]): Promise<unknown>;
-}

package/dist/server/entities/altv/player/AltVPlayerNetManager.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AltVPlayerNetManager = void 0;
-class AltVPlayerNetManager {
-    _player;
-    constructor(player) {
-        this._player = player;
-    }
-    callEvent(eventName, ...args) {
-        return this._player.emit(eventName, ...args);
-    }
-    callRPC(rpcName, ...args) {
-        return this._player.emitRpc(rpcName, ...args);
-    }
-}
-exports.AltVPlayerNetManager = AltVPlayerNetManager;

package/dist/server/entities/common/player/IPlayerNetManager.d.ts

@@ -1,4 +0,0 @@
-export interface IPlayerNetManager {
-    callEvent(eventName: string, ...args: unknown[]): void;
-    callRPC(rpcName: string, ...args: unknown[]): Promise<unknown>;
-}

package/dist/server/entities/common/player/IPlayerNetManager.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/ragemp/player/RagePlayerNetManager.d.ts

@@ -1,7 +0,0 @@
-import { IPlayerNetManager } from "../../common/player/IPlayerNetManager";
-export declare class RagePlayerNetManager implements IPlayerNetManager {
-    private readonly _player;
-    constructor(player: PlayerMp);
-    callEvent(eventName: string, ...args: unknown[]): void;
-    callRPC(rpcName: string, ...args: unknown[]): Promise<unknown>;
-}

package/dist/server/entities/ragemp/player/RagePlayerNetManager.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RagePlayerNetManager = void 0;
-class RagePlayerNetManager {
-    _player;
-    constructor(player) {
-        this._player = player;
-    }
-    callEvent(eventName, ...args) {
-        return this._player.call(eventName, args);
-    }
-    callRPC(rpcName, ...args) {
-        return this._player.callProc(rpcName, args);
-    }
-}
-exports.RagePlayerNetManager = RagePlayerNetManager;