rock-mod 0.0.1 → 0.1.0

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

@@ -1,13 +1,46 @@
-import { RageEntity } from "../entity/RageEntity";
-import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
-export declare class RagePlayer extends RageEntity implements IPlayer {
-    private _name;
-    private readonly _socialClub;
-    private _health;
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { ICustomization, IPlayer } from "../../common/player/IPlayer";
+import { RagePlayerNetManager } from "./RagePlayerNetManager";
+import { RageVehicle } from "../vehicle/RageVehicle";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
+}
+export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
+    private readonly _net;
+    get net(): RagePlayerNetManager;
     get name(): string;
     get socialClub(): string;
+    get heading(): number;
     get health(): number;
-    constructor(options: IPlayerOptions);
-    setName(value: string): void;
+    get armour(): number;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): RageVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): RagePlayer[];
+    get isExists(): boolean;
+    constructor(options: IRagePlayerOptions);
+    spawn(position: Vector3D): void;
+    setName(name: string): void;
+    setHeading(value: number): void;
     setHealth(value: number): void;
+    setArmour(value: number): void;
+    setWeaponAmmo(weapon: string, ammo: number): void;
+    giveWeapon(weapon: string, ammo: number): void;
+    removeWeapon(weapon: string): void;
+    enableVoiceTo(player: RagePlayer): void;
+    disableVoiceTo(player: RagePlayer): void;
+    putIntoVehicle(vehicle: RageVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(data: ICustomization): void;
+    setHeadOverlay(overlayID: number, index: number, opacity: number, firstColor: number, secondColor: number): void;
+    setEyeColor(colorID: number): void;
+    setProp(propID: number, drawableID: number, textureID: number): void;
+    setClothes(componentID: number, drawableID: number, textureID: number, paletteID: number): void;
+    setHairColor(colorID: number, highlightColorID: number): void;
+    kick(reason?: string): void;
 }
+export {};

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

@@ -2,30 +2,127 @@
 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 {
-    _name;
-    _socialClub;
-    _health;
+    _net;
+    get net() {
+        return this._net;
+    }
     get name() {
-        return this._name;
+        return this.mpEntity.name;
     }
     get socialClub() {
-        return this._socialClub;
+        return this.mpEntity.socialClub;
+    }
+    get heading() {
+        return this.mpEntity.heading;
     }
     get health() {
-        return this._health;
+        return this.mpEntity.health;
+    }
+    get armour() {
+        return this.mpEntity.armour;
+    }
+    get ip() {
+        return this.mpEntity.ip;
+    }
+    get serial() {
+        return this.mpEntity.serial;
+    }
+    get vehicle() {
+        const mpVehicle = this.mpEntity.vehicle;
+        if (!mpVehicle) {
+            return null;
+        }
+        return RockMod_1.RockMod.instance.vehicles.getByID(mpVehicle.id);
+    }
+    get seat() {
+        return this.mpEntity.seat;
+    }
+    get weapon() {
+        return this.mpEntity.weapon;
+    }
+    get weaponAmmo() {
+        return this.mpEntity.weaponAmmo;
+    }
+    get eyeColor() {
+        return this.mpEntity.eyeColor;
+    }
+    get streamedPlayers() {
+        const players = [];
+        for (const mpEntity of this.mpEntity.streamedPlayers) {
+            players.push(RockMod_1.RockMod.instance.players.getByID(mpEntity.id));
+        }
+        return players;
+    }
+    get isExists() {
+        return mp.players.exists(this.mpEntity);
     }
     constructor(options) {
         super(options);
-        this._name = options.name;
-        this._socialClub = options.socialClub;
-        this._health = 100;
+        this._net = new RagePlayerNetManager_1.RagePlayerNetManager(this.mpEntity);
     }
-    setName(value) {
-        this._name = value;
+    spawn(position) {
+        return this.mpEntity.spawn(new mp.Vector3(position));
+    }
+    setName(name) {
+        this.mpEntity.name = name;
+    }
+    setHeading(value) {
+        this.mpEntity.heading = value;
     }
     setHealth(value) {
-        this._health = value;
+        this.mpEntity.health = Math.clamp(value, 0, 100);
+    }
+    setArmour(value) {
+        this.mpEntity.armour = Math.clamp(value, 0, 100);
+    }
+    setWeaponAmmo(weapon, ammo) {
+        return this.mpEntity.setWeaponAmmo(mp.joaat(weapon), ammo);
+    }
+    giveWeapon(weapon, ammo) {
+        return this.mpEntity.giveWeapon(weapon, ammo);
+    }
+    removeWeapon(weapon) {
+        return this.mpEntity.removeWeapon(weapon);
+    }
+    enableVoiceTo(player) {
+        const mpPlayer = mp.players.at(player.id);
+        return this.mpEntity.enableVoiceTo(mpPlayer);
+    }
+    disableVoiceTo(player) {
+        const mpPlayer = mp.players.at(player.id);
+        return this.mpEntity.disableVoiceTo(mpPlayer);
+    }
+    putIntoVehicle(vehicle, seat) {
+        const mpVehicle = mp.vehicles.at(vehicle.id);
+        return this.mpEntity.putIntoVehicle(mpVehicle, seat || 0);
+    }
+    ejectFromVehicle() {
+        return this.mpEntity.removeFromVehicle();
+    }
+    setCustomization(data) {
+        const { gender, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, eyeColor, hairColor, highlightColor, faceFeatures, } = data;
+        return this.mpEntity.setCustomization(gender, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, eyeColor, hairColor, highlightColor, faceFeatures);
+    }
+    setHeadOverlay(overlayID, index, opacity, firstColor, secondColor) {
+        return this.mpEntity.setHeadOverlay(overlayID, [index, opacity, firstColor, secondColor]);
+    }
+    setEyeColor(colorID) {
+        this.mpEntity.eyeColor = colorID;
+    }
+    setProp(propID, drawableID, textureID) {
+        return this.mpEntity.setProp(propID, drawableID, textureID);
+    }
+    setClothes(componentID, drawableID, textureID, paletteID) {
+        return this.mpEntity.setClothes(componentID, drawableID, textureID, paletteID);
+    }
+    setHairColor(colorID, highlightColorID) {
+        return this.mpEntity.setHairColor(colorID, highlightColorID);
+    }
+    kick(reason) {
+        return this.mpEntity.kick(reason ?? "");
     }
 }
 exports.RagePlayer = RagePlayer;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,16 @@
+"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;

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

@@ -7,4 +7,5 @@ export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer>
     findByName(name: string): RagePlayer | null;
     getBySocialClub(socialClub: string): RagePlayer;
     findBySocialClub(socialClub: string): RagePlayer | null;
+    private _init;
 }

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

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayersManager = void 0;
 const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RagePlayer_1 = require("./RagePlayer");
+const RockMod_1 = require("../../../RockMod");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor() {
         super({
             baseObjectsType: "player",
         });
+        this._init();
     }
     getByName(name) {
         const player = this.findByName(name);
@@ -38,5 +41,22 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         }
         return null;
     }
+    _init() {
+        const net = RockMod_1.RockMod.instance.net;
+        net.events.on({
+            playerJoin: (mpPlayer) => {
+                const player = new RagePlayer_1.RagePlayer({
+                    mpEntity: mpPlayer,
+                });
+                this.registerBaseObject(player);
+                RockMod_1.RockMod.instance.net.events.emit("rm::playerConnected", player);
+            },
+            playerQuit: (mpPlayer) => {
+                const player = this.getByID(mpPlayer.id);
+                this.unregisterBaseObject(player);
+                net.events.emit("rm::playerDisconnected", player);
+            },
+        });
+    }
 }
 exports.RagePlayersManager = RagePlayersManager;

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

@@ -1,8 +1,9 @@
-import { RageEntity } from "../entity/RageEntity";
-import { IVehicle, IVehicleOptions } from "../../common/vehicle/IVehicle";
-export declare class RageVehicle extends RageEntity implements IVehicle {
-    private _bodyHealth;
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { IVehicle } from "../../common/vehicle/IVehicle";
+export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
+}
+export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehicle {
     get bodyHealth(): number;
-    constructor(options: IVehicleOptions);
+    constructor(options: IRageVehicleOptions);
     setBodyHealth(value: number): void;
 }

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

@@ -3,16 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehicle = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
 class RageVehicle extends RageEntity_1.RageEntity {
-    _bodyHealth;
     get bodyHealth() {
-        return this._bodyHealth;
+        return this.mpEntity.bodyHealth;
     }
     constructor(options) {
         super(options);
-        this._bodyHealth = 100;
     }
     setBodyHealth(value) {
-        this._bodyHealth = value;
+        this.mpEntity.bodyHealth = value;
     }
 }
 exports.RageVehicle = RageVehicle;

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

@@ -1,6 +1,9 @@
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RageVehicle } from "./RageVehicle";
-import { IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+export interface IRageVehicleCreateOptions extends IVehicleCreateOptions {
+}
 export declare class RageVehiclesManager extends RageEntitiesManager<RageVehicle> implements IVehiclesManager {
     constructor();
+    create(options: IRageVehicleCreateOptions): RageVehicle;
 }

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

@@ -2,11 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehiclesManager = void 0;
 const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RageVehicle_1 = require("./RageVehicle");
 class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor() {
         super({
             baseObjectsType: "vehicle",
         });
     }
+    create(options) {
+        const { model, position } = options;
+        const mpEntity = mp.vehicles.new(model, new mp.Vector3(position));
+        const vehicle = new RageVehicle_1.RageVehicle({ mpEntity });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
 }
 exports.RageVehiclesManager = RageVehiclesManager;

package/dist/server/entities/ragemp/worldObject/RageWorldObject.d.ts

@@ -1,10 +1,12 @@
-import { IWorldObject, IWorldObjectOptions } from "../../common/worldObject/IWorldObject";
-import { RageBaseObject } from "../baseObject/RageBaseObject";
+import { IWorldObject } from "../../common/worldObject/IWorldObject";
+import { IRageBaseObjectOptions, RageBaseObject } from "../baseObject/RageBaseObject";
 import { Vector3D } from "../../../common/utils/math/Vectors";
-export declare abstract class RageWorldObject extends RageBaseObject implements IWorldObject {
-    private readonly _position;
-    private readonly _dimension;
+export interface IRageWorldObjectOptions<T extends EntityMp> extends IRageBaseObjectOptions<T> {
+}
+export declare abstract class RageWorldObject<T extends EntityMp> extends RageBaseObject<T> implements IWorldObject {
     get position(): Vector3D;
     get dimension(): number;
-    protected constructor(options: IWorldObjectOptions);
+    protected constructor(options: IRageWorldObjectOptions<T>);
+    setPosition(value: Vector3D): void;
+    setDimension(value: number): void;
 }

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

@@ -2,19 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageWorldObject = void 0;
 const RageBaseObject_1 = require("../baseObject/RageBaseObject");
+const Vectors_1 = require("../../../common/utils/math/Vectors");
 class RageWorldObject extends RageBaseObject_1.RageBaseObject {
-    _position;
-    _dimension;
     get position() {
-        return this._position;
+        const { x, y, z } = this.mpEntity.position;
+        return new Vectors_1.Vector3D(x, y, z);
     }
     get dimension() {
-        return this._dimension;
+        return this.mpEntity.dimension;
     }
     constructor(options) {
         super(options);
-        this._position = options.position;
-        this._dimension = options.dimension;
+    }
+    setPosition(value) {
+        this.mpEntity.position = new Vector3(value);
+    }
+    setDimension(value) {
+        this.mpEntity.dimension = value;
     }
 }
 exports.RageWorldObject = RageWorldObject;

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsIterator.d.ts

@@ -2,7 +2,7 @@ import { RageWorldObject } from "./RageWorldObject";
 import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
 import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
 import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
-export declare class RageWorldObjectsIterator<T extends RageWorldObject> extends RageBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+export declare class RageWorldObjectsIterator<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
     constructor(baseObjects: ReadonlyMap<number, T>);
     dimension(value: number): IterableIterator<T>;
     range2D(center: Vector2D, range: number): IterableIterator<T>;

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsManager.d.ts

@@ -1,9 +1,11 @@
-import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../../common/worldObject/IWorldObjectsManager";
-import { RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
+import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { IRageBaseObjectsManagerOptions, RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
 import { RageWorldObject } from "./RageWorldObject";
 import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";
-export declare abstract class RageWorldObjectsManager<T extends RageWorldObject> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+export interface IRageWorldObjectsManagerOptions extends IRageBaseObjectsManagerOptions {
+}
+export declare abstract class RageWorldObjectsManager<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
     protected readonly _iterator: RageWorldObjectsIterator<T>;
     get iterator(): RageWorldObjectsIterator<T>;
-    protected constructor(options: IWorldObjectsManagerOptions);
+    protected constructor(options: IRageWorldObjectsManagerOptions);
 }

package/dist/server/factories/altv/AltVManagersFactory.d.ts

@@ -0,0 +1,9 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { AltVNetManager } from "../../net/altv/AltVNetManager";
+import { AltVPlayersManager } from "../../entities/altv/player/AltVPlayersManager";
+import { AltVVehiclesManager } from "../../entities/altv/vehicle/AltVVehiclesManager";
+export declare class AltVManagersFactory implements IManagersFactory {
+    createNetManager(): AltVNetManager;
+    createPlayersManager(): AltVPlayersManager;
+    createVehiclesManager(): AltVVehiclesManager;
+}

package/dist/server/{entities → factories}/altv/AltVManagersFactory.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVManagersFactory = void 0;
-const AltVPlayersManager_1 = require("./player/AltVPlayersManager");
-const AltVVehiclesManager_1 = require("./vehicle/AltVVehiclesManager");
+const AltVNetManager_1 = require("../../net/altv/AltVNetManager");
+const AltVPlayersManager_1 = require("../../entities/altv/player/AltVPlayersManager");
+const AltVVehiclesManager_1 = require("../../entities/altv/vehicle/AltVVehiclesManager");
 class AltVManagersFactory {
+    createNetManager() {
+        return new AltVNetManager_1.AltVNetManager();
+    }
     createPlayersManager() {
         return new AltVPlayersManager_1.AltVPlayersManager();
     }

package/dist/server/factories/common/IManagersFactory.d.ts

@@ -0,0 +1,8 @@
+import { INetManager } from "../../net/common/INetManager";
+import { IPlayersManager } from "../../entities/common/player/IPlayersManager";
+import { IVehiclesManager } from "../../entities/common/vehicle/IVehiclesManager";
+export interface IManagersFactory {
+    createNetManager(): INetManager;
+    createPlayersManager(): IPlayersManager;
+    createVehiclesManager(): IVehiclesManager;
+}

package/dist/server/factories/common/IManagersFactory.js

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

package/dist/server/factories/ragemp/RageManagersFactory.d.ts

@@ -0,0 +1,9 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { RageNetManager } from "../../net/ragemp/RageNetManager";
+import { RagePlayersManager } from "../../entities/ragemp/player/RagePlayersManager";
+import { RageVehiclesManager } from "../../entities/ragemp/vehicle/RageVehiclesManager";
+export declare class RageManagersFactory implements IManagersFactory {
+    createNetManager(): RageNetManager;
+    createPlayersManager(): RagePlayersManager;
+    createVehiclesManager(): RageVehiclesManager;
+}

package/dist/server/{entities → factories}/ragemp/RageManagersFactory.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageManagersFactory = void 0;
-const RagePlayersManager_1 = require("./player/RagePlayersManager");
-const RageVehiclesManager_1 = require("./vehicle/RageVehiclesManager");
+const RageNetManager_1 = require("../../net/ragemp/RageNetManager");
+const RagePlayersManager_1 = require("../../entities/ragemp/player/RagePlayersManager");
+const RageVehiclesManager_1 = require("../../entities/ragemp/vehicle/RageVehiclesManager");
 class RageManagersFactory {
+    createNetManager() {
+        return new RageNetManager_1.RageNetManager();
+    }
     createPlayersManager() {
         return new RagePlayersManager_1.RagePlayersManager();
     }

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RockMod";
+export * from "./entities";
+export * from "./common/utils";

package/dist/server/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RockMod"), exports);
+__exportStar(require("./entities"), exports);
+__exportStar(require("./common/utils"), exports);

package/dist/server/net/altv/AltVNetManager.d.ts

@@ -0,0 +1,10 @@
+import { INetManager } from "../common/INetManager";
+import { AltVEventsManager } from "./events/AltVEventsManager";
+import { AltVRPCManager } from "./rpc/AltVRPCManager";
+export declare class AltVNetManager implements INetManager {
+    private readonly _eventsManager;
+    private readonly _rpcManager;
+    get events(): AltVEventsManager;
+    get rpc(): AltVRPCManager;
+    constructor();
+}

package/dist/server/net/altv/AltVNetManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVNetManager = void 0;
+const AltVEventsManager_1 = require("./events/AltVEventsManager");
+const AltVRPCManager_1 = require("./rpc/AltVRPCManager");
+class AltVNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new AltVEventsManager_1.AltVEventsManager();
+        this._rpcManager = new AltVRPCManager_1.AltVRPCManager();
+    }
+}
+exports.AltVNetManager = AltVNetManager;

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

@@ -0,0 +1,16 @@
+import { IEventsManager, 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 {
+    "rm::entityCreated"(baseObject: AltVBaseObject<alt.BaseObject>): void;
+    "rm::entityDestroyed"(baseObject: AltVBaseObject<alt.BaseObject>): void;
+}
+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;
+}
+export {};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVEventsManager = void 0;
+var alt = AltVServer;
+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
+        return alt.off(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        return alt.emit(eventName, ...args);
+    }
+    emitClient(player, eventName, ...args) {
+        return player.net.callEvent(eventName, ...args);
+    }
+}
+exports.AltVEventsManager = AltVEventsManager;

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

@@ -0,0 +1,11 @@
+import { IRPCManager } from "../../common/rpc/IRPCManager";
+import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
+import shared = AltVShared;
+interface IAltVRPCName extends shared.ICustomClientServerRpc {
+}
+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>;
+}
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVRPCManager = void 0;
+var alt = AltVServer;
+class AltVRPCManager {
+    register(rpcName, handler) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return alt.onRpc(rpcName, handler);
+    }
+    unregister(rpcName) {
+        return alt.offRpc(rpcName);
+    }
+    callClient(player, rpcName, ...args) {
+        return player.net.callRPC(rpcName, ...args);
+    }
+}
+exports.AltVRPCManager = AltVRPCManager;

package/dist/server/net/common/INetManager.d.ts

@@ -0,0 +1,6 @@
+import { IEventsManager } from "./events/IEventsManager";
+import { IRPCManager } from "./rpc/IRPCManager";
+export interface INetManager {
+    get events(): IEventsManager;
+    get rpc(): IRPCManager;
+}

package/dist/server/net/common/INetManager.js

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