rock-mod 0.8.3 → 0.9.1

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayer = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
 const RockMod_1 = require("../../../RockMod");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
 class RagePlayer extends RageEntity_1.RageEntity {
     get name() {
         return this.mpEntity.name;
@@ -73,10 +74,10 @@ class RagePlayer extends RageEntity_1.RageEntity {
         this.mpEntity.heading = value;
     }
     setHealth(value) {
-        this.mpEntity.health = Math.clamp(value, 0, 100);
+        this.mpEntity.health = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setArmour(value) {
-        this.mpEntity.armour = Math.clamp(value, 0, 100);
+        this.mpEntity.armour = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setWeaponAmmo(weapon, ammo) {
         return this.mpEntity.setWeaponAmmo(mp.joaat(weapon), ammo);

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

@@ -1,7 +1,7 @@
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RagePlayer } from "./RagePlayer";
-import { IPlayersManager } from "../../common/player/IPlayersManager";
-import { RageNetManager } from "../../../net/ragemp/RageNetManager";
+import { type IPlayersManager } from "../../common/player/IPlayersManager";
+import { type RageNetManager } from "../../../net/ragemp/RageNetManager";
 export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer> implements IPlayersManager {
     constructor(net: RageNetManager);
     getByName(name: string): RagePlayer;

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

@@ -3,7 +3,7 @@ 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");
+const types_1 = require("../../../net/common/events/types");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor(net) {
         super({
@@ -42,19 +42,19 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         return null;
     }
     _init(net) {
-        net.events.on({
+        net.events.onInternal({
             playerJoin: (mpPlayer) => {
                 mpPlayer.isExists = () => mp.players.exists(mpPlayer);
                 const player = new RagePlayer_1.RagePlayer({
                     mpEntity: mpPlayer,
                 });
                 this.registerBaseObject(player);
-                RockMod_1.RockMod.instance.net.events.emit("rm::playerConnected", player);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerConnected, player);
             },
             playerQuit: (mpPlayer) => {
                 const player = this.getByID(mpPlayer.id);
                 this.unregisterBaseObject(player);
-                net.events.emit("rm::playerDisconnected", player);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
             },
         });
     }

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

@@ -1,7 +1,7 @@
-import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { IVehicle } from "../../common/vehicle/IVehicle";
-import { RGBA } from "../../../common/utils";
-import { RagePlayer } from "../player/RagePlayer";
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { RGBA } from "../../../../shared/common/utils";
+import { type RagePlayer } from "../player/RagePlayer";
 export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
 }
 export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehicle {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehicle = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 const RockMod_1 = require("../../../RockMod");
 class RageVehicle extends RageEntity_1.RageEntity {
     get bodyHealth() {

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

@@ -1,6 +1,6 @@
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RageVehicle } from "./RageVehicle";
-import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { type IVehicleCreateOptions, type IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
 export interface IRageVehicleCreateOptions extends IVehicleCreateOptions {
 }
 export declare class RageVehiclesManager extends RageEntitiesManager<RageVehicle> implements IVehiclesManager {

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

@@ -1,6 +1,6 @@
-import { IWorldObject } from "../../common/worldObject/IWorldObject";
-import { IRageBaseObjectOptions, RageBaseObject } from "../baseObject/RageBaseObject";
-import { Vector3D } from "../../../common/utils/math/Vectors";
+import { type IWorldObject } from "../../common/worldObject/IWorldObject";
+import { type IRageBaseObjectOptions, RageBaseObject } from "../baseObject/RageBaseObject";
+import { Vector3D } from "../../../../shared/common/utils/math/Vectors";
 export interface IRageWorldObjectOptions<T extends EntityMp> extends IRageBaseObjectOptions<T> {
 }
 export declare abstract class RageWorldObject<T extends EntityMp> extends RageBaseObject<T> implements IWorldObject {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageWorldObject = void 0;
 const RageBaseObject_1 = require("../baseObject/RageBaseObject");
-const Vectors_1 = require("../../../common/utils/math/Vectors");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
 class RageWorldObject extends RageBaseObject_1.RageBaseObject {
     get position() {
         const { x, y, z } = this.mpEntity.position;

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

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

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

@@ -1,6 +1,6 @@
-import { IWorldObjectsManager } from "../../common";
-import { IRageBaseObjectsManagerOptions, RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
-import { RageWorldObject } from "./RageWorldObject";
+import { type IWorldObjectsManager } from "../../common";
+import { type IRageBaseObjectsManagerOptions, RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
+import { type RageWorldObject } from "./RageWorldObject";
 import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";
 export interface IRageWorldObjectsManagerOptions extends IRageBaseObjectsManagerOptions {
 }

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

@@ -1,4 +1,4 @@
-import { IManagersFactory } from "../common/IManagersFactory";
+import { type IManagersFactory } from "../common/IManagersFactory";
 import { AltVNetManager } from "../../net/altv/AltVNetManager";
 import { AltVBlipsManager } from "../../entities/altv/blip/AltVBlipsManager";
 import { AltVColshapesManager } from "../../entities/altv/colshape/AltVColshapesManager";

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

@@ -1,6 +1,6 @@
-import { INetManager } from "../../net/common/INetManager";
-import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "../../entities";
-import { IUtilsManager } from "../../utils";
+import { type INetManager } from "../../net/common/INetManager";
+import { type IBlipsManager, type IColshapesManager, type IMarkersManager, type IObjectsManager, type IPedsManager, type IPlayersManager, type IVehiclesManager } from "../../entities";
+import { type IUtilsManager } from "../../utils";
 export interface IManagersFactory {
     createNetManager(): INetManager;
     createBlipsManager(): IBlipsManager;

package/dist/server/factories/mock/MockManagersFactory.d.ts

@@ -1,7 +1,7 @@
-import { IManagersFactory } from "../common/IManagersFactory";
+import { type IManagersFactory } from "../common/IManagersFactory";
 import { MockNetManager } from "../../net/mock/MockNetManager";
 import { MockPlayersManager } from "../../entities/mock/player/MockPlayersManager";
-import { IUtilsManager } from "../../utils";
+import { type IUtilsManager } from "../../utils";
 import { MockBlipsManager } from "../../entities/mock/blip/MockBlipsManager";
 import { MockColshapesManager } from "../../entities/mock/colshape/MockColshapesManager";
 import { MockMarkersManager } from "../../entities/mock/marker/MockMarkersManager";

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

@@ -1,4 +1,4 @@
-import { IManagersFactory } from "../common/IManagersFactory";
+import { type IManagersFactory } from "../common/IManagersFactory";
 import { RageNetManager } from "../../net/ragemp/RageNetManager";
 import { RageBlipsManager } from "../../entities/ragemp/blip/RageBlipsManager";
 import { RageColshapesManager } from "../../entities/ragemp/colshape/RageColshapesManager";

package/dist/server/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./RockMod";
-export { IRGBA as IRockModRGBA, RGBA as RockModRGBA } from "./common/utils/color";
-export { IVector2D as IRockModVector2D, IVector3D as IRockModVector3D, Vector2D as RockModVector2D, Vector3D as RockModVector3D, } from "./common/utils/math";
-export { BaseObjectType, IBaseObject as IRockModBaseObject, IBlip as IRockModBlip, IColshape as IRockModColshape, IEntity as IRockModEntity, IMarker as IRockModMarker, IObject as IRockModObject, IPed as IRockModPed, IPlayer as IRockModPlayer, IVehicle as IRockModVehicle, IWorldObject as IRockModWorldObject, } from "./entities";
-export { INetServerEvents, INetClientEvents } from "./net/common/events/IEventsManager";
-export { INetServerRPC, INetClientRPC } from "./net/common/rpc/IRPCManager";
+export { IRGBA as IRockModRGBA, RGBA as RockModRGBA } from "../shared/common/utils/color";
+export { IVector2D as IRockModVector2D, IVector3D as IRockModVector3D, Vector2D as RockModVector2D, Vector3D as RockModVector3D, } from "../shared/common/utils/math";
+export { BaseObjectType as RockModBaseObjectType } from "../shared/entities/IBaseObject";
+export { IBaseObject as IRockModBaseObject, IBlip as IRockModBlip, IColshape as IRockModColshape, IEntity as IRockModEntity, IMarker as IRockModMarker, IObject as IRockModObject, IPed as IRockModPed, IPlayer as IRockModPlayer, IVehicle as IRockModVehicle, IWorldObject as IRockModWorldObject, } from "./entities";
 export * from "./testing";

package/dist/server/index.js

@@ -14,13 +14,13 @@ 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 });
-exports.BaseObjectType = exports.RockModVector3D = exports.RockModVector2D = exports.RockModRGBA = void 0;
+exports.RockModBaseObjectType = exports.RockModVector3D = exports.RockModVector2D = exports.RockModRGBA = void 0;
 __exportStar(require("./RockMod"), exports);
-var color_1 = require("./common/utils/color");
+var color_1 = require("../shared/common/utils/color");
 Object.defineProperty(exports, "RockModRGBA", { enumerable: true, get: function () { return color_1.RGBA; } });
-var math_1 = require("./common/utils/math");
+var math_1 = require("../shared/common/utils/math");
 Object.defineProperty(exports, "RockModVector2D", { enumerable: true, get: function () { return math_1.Vector2D; } });
 Object.defineProperty(exports, "RockModVector3D", { enumerable: true, get: function () { return math_1.Vector3D; } });
-var entities_1 = require("./entities");
-Object.defineProperty(exports, "BaseObjectType", { enumerable: true, get: function () { return entities_1.BaseObjectType; } });
+var IBaseObject_1 = require("../shared/entities/IBaseObject");
+Object.defineProperty(exports, "RockModBaseObjectType", { enumerable: true, get: function () { return IBaseObject_1.BaseObjectType; } });
 __exportStar(require("./testing"), exports);

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

@@ -1,4 +1,4 @@
-import { INetManager } from "../common/INetManager";
+import { type INetManager } from "../common/INetManager";
 import { AltVEventsManager } from "./events/AltVEventsManager";
 import { AltVRPCManager } from "./rpc/AltVRPCManager";
 export declare class AltVNetManager implements INetManager {

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

@@ -1,16 +1,15 @@
-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";
-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 {
+import { type IEventsManager } from "../../common/events/IEventsManager";
+import { type IServerInternalEvents } from "../../common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared";
+import { type AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
+interface IAltVServerInternalEvents extends IServerInternalEvents, AltVServer.IServerEvent {
 }
 export declare class AltVEventsManager implements IEventsManager {
-    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;
+    onInternal(events: Partial<IAltVServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: AltVPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
+export {};

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

@@ -1,21 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVEventsManager = void 0;
-var alt = AltVServer;
 var Player = AltVServer.Player;
 class AltVEventsManager {
-    on(events) {
+    onInternal(events) {
         for (const eventName of Object.keys(events)) {
-            alt.on(eventName, events[eventName]);
+            // @ts-expect-error Add types
+            AltVServer.on(eventName, events[eventName]);
         }
     }
-    off(eventName, listener) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return alt.off(eventName, listener);
+    offInternal(eventName, listener) {
+        AltVServer.off(eventName, listener);
     }
-    emit(eventName, ...args) {
-        return alt.emit(eventName, ...args);
+    emitInternal(eventName, ...args) {
+        AltVServer.emit(eventName, ...args);
+    }
+    onClient(events) {
+        for (const eventName of Object.keys(events)) {
+            // @ts-expect-error Add types
+            AltVServer.onClient(eventName, events[eventName]);
+        }
+    }
+    offClient(eventName, listener) {
+        AltVServer.offClient(eventName, listener);
     }
     emitClient(player, eventName, ...args) {
         const mpPlayer = Player.getByID(player.id);

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

@@ -1,9 +1,10 @@
-import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
-import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
 import shared = AltVShared;
-export interface IAltVServerRPC extends shared.ICustomClientServerRpc, INetServerRPC {
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
+export interface IAltVServerRPC extends shared.ICustomClientServerRpc, IServerRPCList {
 }
-export interface IAltVClientRPC extends shared.ICustomServerClientRpc, INetClientRPC {
+export interface IAltVClientRPC extends shared.ICustomServerClientRpc, IClientRPCList {
 }
 export declare class AltVRPCManager implements IRPCManager {
     register<K extends keyof IAltVServerRPC>(rpcName: K, handler: (player: AltVPlayer, ...args: Parameters<IAltVServerRPC[K]>) => ReturnType<IAltVServerRPC[K]>): void;

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

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

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

@@ -1,16 +1,11 @@
-import { IPlayer } from "../../../entities/common/player/IPlayer";
-import { IBaseObject } from "../../../entities/common/baseObject/IBaseObject";
-export interface INetServerEvents {
-    "rm::playerConnected"(player: IPlayer): void;
-    "rm::playerDisconnected"(player: IPlayer): void;
-    "rm::entityCreated"(entity: IBaseObject): void;
-    "rm::entityDestroyed"(entity: IBaseObject): void;
-}
-export interface INetClientEvents {
-}
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared";
+import { type IServerInternalEvents } from "./types";
+import { type IPlayer } from "../../../entities";
 export interface IEventsManager {
-    on<K extends keyof INetServerEvents>(events: Record<K, (...args: Parameters<INetServerEvents[K]>) => void>): 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;
+    onInternal(events: Partial<IServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: IPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

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

@@ -0,0 +1,13 @@
+import { type IBaseObject, type IPlayer } from "../../../entities";
+export declare enum ServerInternalEventName {
+    PlayerConnected = "rm::playerConnected",
+    PlayerDisconnected = "rm::playerDisconnected",
+    EntityCreated = "rm::entityCreated",
+    EntityDestroyed = "rm::entityDestroyed"
+}
+export interface IServerInternalEvents {
+    [ServerInternalEventName.PlayerConnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.PlayerDisconnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.EntityCreated]: (object: IBaseObject) => void;
+    [ServerInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
+}

package/dist/server/net/common/events/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerInternalEventName = void 0;
+var ServerInternalEventName;
+(function (ServerInternalEventName) {
+    ServerInternalEventName["PlayerConnected"] = "rm::playerConnected";
+    ServerInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
+    ServerInternalEventName["EntityCreated"] = "rm::entityCreated";
+    ServerInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
+})(ServerInternalEventName || (exports.ServerInternalEventName = ServerInternalEventName = {}));

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

@@ -1,10 +1,7 @@
-import { IPlayer } from "../../../entities/common/player/IPlayer";
-export interface INetServerRPC {
-}
-export interface INetClientRPC {
-}
+import { type IPlayer } from "../../../entities/common/player/IPlayer";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
 export interface IRPCManager {
-    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]>>;
+    register<K extends keyof IServerRPCList>(rpcName: K, handler: (player: IPlayer, ...args: Parameters<IServerRPCList[K]>) => ReturnType<IServerRPCList[K]>): void;
+    unregister<K extends keyof IServerRPCList>(rpcName: K): void;
+    emitClient<K extends keyof IClientRPCList>(player: IPlayer, rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
 }

package/dist/server/net/mock/MockNetManager.d.ts

@@ -1,4 +1,4 @@
-import { INetManager } from "../common/INetManager";
+import { type INetManager } from "../common/INetManager";
 import { MockEventsManager } from "./events/MockEventsManager";
 import { MockRPCManager } from "./rpc/MockRPCManager";
 export declare class MockNetManager implements INetManager {

package/dist/server/net/mock/events/MockEventsManager.d.ts

@@ -1,18 +1,13 @@
-import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
-import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
-import { MockBaseObject } from "../../../entities/mock/baseObject/MockBaseObject";
-export interface IMockServerEvents extends INetServerEvents {
-    "rm::playerConnected"(player: MockPlayer): void;
-    "rm::playerDisconnected"(player: MockPlayer): void;
-    "rm::entityCreated"(entity: MockBaseObject): void;
-    "rm::entityDestroyed"(entity: MockBaseObject): void;
-}
-export interface IMockClientEvents extends INetClientEvents {
-}
+import { type IEventsManager } from "../../common/events/IEventsManager";
+import { type IServerInternalEvents } from "../../common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared";
+import { type MockPlayer } from "../../../entities/mock/player/MockPlayer";
 export declare class MockEventsManager implements IEventsManager {
     private readonly _eventEmitter;
-    on<K extends keyof IMockServerEvents>(events: Record<K, (...args: Parameters<IMockServerEvents[K]>) => void>): void;
-    off<K extends keyof IMockServerEvents>(eventName: K, listener: (...args: Parameters<IMockServerEvents[K]>) => void): void;
-    emit<K extends keyof IMockServerEvents>(eventName: K, ...args: Parameters<IMockServerEvents[K]>): void;
-    emitClient(): void;
+    onInternal(events: Partial<IServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: MockPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

package/dist/server/net/mock/events/MockEventsManager.js

@@ -4,19 +4,27 @@ exports.MockEventsManager = void 0;
 const events_1 = require("events");
 class MockEventsManager {
     _eventEmitter = new events_1.EventEmitter();
-    on(events) {
+    onInternal(events) {
         for (const [eventName, handler] of Object.entries(events)) {
             this._eventEmitter.on(eventName, handler);
         }
     }
-    off(eventName, listener) {
+    offInternal(eventName, listener) {
         this._eventEmitter.off(eventName, listener);
     }
-    emit(eventName, ...args) {
+    emitInternal(eventName, ...args) {
         this._eventEmitter.emit(eventName, ...args);
     }
-    emitClient() {
-        throw new Error("Method not implemented");
+    onClient(events) {
+        for (const [eventName, handler] of Object.entries(events)) {
+            this._eventEmitter.on(eventName, handler);
+        }
+    }
+    offClient(eventName, listener) {
+        this._eventEmitter.off(eventName, listener);
+    }
+    emitClient(player, eventName, ...args) {
+        this._eventEmitter.emit(eventName, player, ...args);
     }
 }
 exports.MockEventsManager = MockEventsManager;

package/dist/server/net/mock/rpc/MockRPCManager.d.ts

@@ -1,9 +1,10 @@
-import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
-import { IPlayer } from "../../../entities/common/player/IPlayer";
-import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
-export interface IMockServerRPC extends INetServerRPC {
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type IPlayer } from "../../../entities/common/player/IPlayer";
+import { type MockPlayer } from "../../../entities/mock/player/MockPlayer";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
+export interface IMockServerRPC extends IServerRPCList {
 }
-export interface IMockClientRPC extends INetClientRPC {
+export interface IMockClientRPC extends IClientRPCList {
 }
 export declare class MockRPCManager implements IRPCManager {
     private readonly _handlers;

package/dist/server/net/ragemp/RageNetManager.d.ts

@@ -1,4 +1,4 @@
-import { INetManager } from "../common/INetManager";
+import { type INetManager } from "../common/INetManager";
 import { RageEventsManager } from "./events/RageEventsManager";
 import { RageRPCManager } from "./rpc/RageRPCManager";
 export declare class RageNetManager implements INetManager {

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

@@ -1,19 +1,15 @@
-import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
-import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
-import { RageBaseObject } from "../../../entities/ragemp/baseObject/RageBaseObject";
-export interface IRageServerEvents extends IServerEvents, INetServerEvents {
-    "rm::playerConnected"(player: RagePlayer): void;
-    "rm::playerDisconnected"(player: RagePlayer): void;
-    "rm::entityCreated"(entity: RageBaseObject): void;
-    "rm::entityDestroyed"(entity: RageBaseObject): void;
-    playerJoin(player: PlayerMp): void;
-    playerQuit(player: PlayerMp): void;
-}
-export interface IRageClientEvents extends INetClientEvents {
+import { type IEventsManager } from "../../common/events/IEventsManager";
+import { type IServerInternalEvents } from "../../common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared";
+import { type RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
+interface IRageServerInternalEvents extends IServerInternalEvents, IServerEvents {
 }
 export declare class RageEventsManager implements IEventsManager {
-    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;
+    onInternal(events: Partial<IRageServerInternalEvents>): void;
+    offInternal<K extends keyof IRageServerInternalEvents>(eventName: K): void;
+    emitInternal<K extends keyof IRageServerInternalEvents>(eventName: K, ...args: Parameters<IRageServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: RagePlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
+export {};

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

@@ -2,16 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageEventsManager = void 0;
 class RageEventsManager {
-    on(events) {
-        for (const eventName of Object.keys(events)) {
-            mp.events.add(eventName, events[eventName]);
-        }
+    onInternal(events) {
+        mp.events.add(events);
+    }
+    offInternal(eventName) {
+        mp.events.remove(eventName);
+    }
+    emitInternal(eventName, ...args) {
+        mp.events.call(eventName, ...args);
     }
-    off(eventName, listener) {
-        return mp.events.remove(eventName, listener);
+    onClient(events) {
+        mp.events.add(events);
     }
-    emit(eventName, ...args) {
-        return mp.events.call(eventName, ...args);
+    offClient(eventName) {
+        mp.events.remove(eventName);
     }
     emitClient(player, eventName, ...args) {
         const mpPlayer = mp.players.at(player.id);

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

@@ -1,11 +1,8 @@
-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 {
-}
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
 export declare class RageRPCManager implements IRPCManager {
-    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]>>;
+    register<K extends keyof IServerRPCList>(rpcName: K, handler: (player: RagePlayer, ...args: Parameters<IServerRPCList[K]>) => ReturnType<IServerRPCList[K]>): void;
+    unregister<K extends keyof IServerRPCList>(rpcName: K): void;
+    emitClient<K extends keyof IClientRPCList>(player: RagePlayer, rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
 }

package/dist/server/testing.d.ts

@@ -1,4 +1,4 @@
-import { MockPlayer } from "entities/mock/player/MockPlayer";
+import { type MockPlayer } from "entities/mock/player/MockPlayer";
 import { IMockPlayerConnectOptions } from "./entities/mock/player/MockPlayersManager";
 export declare class RockModTesting {
     static simulatePlayerConnect(options?: IMockPlayerConnectOptions): MockPlayer;

package/dist/server/utils/altv/AltVUtilsManager.d.ts

@@ -1,4 +1,4 @@
-import { IUtilsManager } from "../common";
+import { type IUtilsManager } from "../common";
 export declare class AltVUtilsManager implements IUtilsManager {
     hash(value: string): number;
 }

package/dist/server/utils/mock/MockUtilsManager.d.ts

@@ -1,4 +1,4 @@
-import { IUtilsManager } from "../common";
+import { type IUtilsManager } from "../common";
 export declare class MockUtilsManager implements IUtilsManager {
     hash(value: string): number;
 }

package/dist/server/utils/ragemp/RageUtilsManager.d.ts

@@ -1,4 +1,4 @@
-import { IUtilsManager } from "../common";
+import { type IUtilsManager } from "../common";
 export declare class RageUtilsManager implements IUtilsManager {
     hash(value: string): number;
 }

package/dist/shared/common/utils/math/Math.d.ts

@@ -0,0 +1 @@
+export declare function MathClamp(value: number, min: number, max: number): number;