rock-mod 0.8.3 → 0.9.1

package/dist/server/entities/mock/marker/MockMarker.d.ts

@@ -1,7 +1,7 @@
-import { IMarker } from "../../common/marker/IMarker";
-import { MockWorldObject, IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
-import { IRGBA, IVector3D } from "../../../common/utils";
-import { IMarkerType } from "../../common";
+import { type IMarker } from "../../common/marker/IMarker";
+import { MockWorldObject, type IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
+import { type IRGBA, type IVector3D } from "../../../../shared/common/utils";
+import { IMarkerType } from "../../../../shared";
 export interface IMockMarkerOptions extends IMockWorldObjectOptions {
     markerType?: IMarkerType;
     scale?: number;

package/dist/server/entities/mock/marker/MockMarker.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockMarker = void 0;
 const MockWorldObject_1 = require("../worldObject/MockWorldObject");
-const utils_1 = require("../../../common/utils");
-const common_1 = require("../../common");
+const utils_1 = require("../../../../shared/common/utils");
+const shared_1 = require("../../../../shared");
 class MockMarker extends MockWorldObject_1.MockWorldObject {
     _markerType;
     _visible;
@@ -27,7 +27,7 @@ class MockMarker extends MockWorldObject_1.MockWorldObject {
     }
     constructor(options) {
         super(options);
-        const { markerType = common_1.IMarkerType.MarkerArrow, scale = 1, color = new utils_1.RGBA(255, 255, 255), rotation = new utils_1.Vector3D(0, 0, 0), } = options;
+        const { markerType = shared_1.IMarkerType.MarkerArrow, scale = 1, color = new utils_1.RGBA(255, 255, 255), rotation = new utils_1.Vector3D(0, 0, 0), } = options;
         this._markerType = markerType;
         this._visible = true;
         this._scale = scale;

package/dist/server/entities/mock/marker/MockMarkersManager.d.ts

@@ -1,4 +1,4 @@
-import { IMarkerCreateOptions, IMarkersManager } from "../../common/marker/IMarkersManager";
+import { type IMarkerCreateOptions, type IMarkersManager } from "../../common/marker/IMarkersManager";
 import { MockWorldObjectsManager } from "../worldObject/MockWorldObjectsManager";
 import { MockMarker } from "./MockMarker";
 export interface IMockMarkerCreateOptions extends IMarkerCreateOptions {

package/dist/server/entities/mock/marker/MockMarkersManager.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockMarkersManager = void 0;
 const MockWorldObjectsManager_1 = require("../worldObject/MockWorldObjectsManager");
 const MockMarker_1 = require("./MockMarker");
-const common_1 = require("../../common");
+const shared_1 = require("../../../../shared");
 class MockMarkersManager extends MockWorldObjectsManager_1.MockWorldObjectsManager {
     _nextId;
     constructor() {
@@ -16,7 +16,7 @@ class MockMarkersManager extends MockWorldObjectsManager_1.MockWorldObjectsManag
         const { type, scale, color, position, dimension, rotation } = options;
         const marker = new MockMarker_1.MockMarker({
             id: this._nextId++,
-            type: common_1.BaseObjectType.Marker,
+            type: shared_1.BaseObjectType.Marker,
             markerType: type,
             scale,
             color,

package/dist/server/entities/mock/object/MockObject.d.ts

@@ -1,5 +1,5 @@
-import { IObject } from "../../common/object/IObject";
-import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+import { type IObject } from "../../common/object/IObject";
+import { MockEntity, type IMockEntityOptions } from "../entity/MockEntity";
 export interface IMockObjectOptions extends IMockEntityOptions {
     alpha?: number;
 }

package/dist/server/entities/mock/object/MockObjectsManager.d.ts

@@ -1,4 +1,4 @@
-import { IObjectCreateOptions, IObjectsManager } from "../../common/object/IObjectsManager";
+import { type IObjectCreateOptions, type IObjectsManager } from "../../common/object/IObjectsManager";
 import { MockEntitiesManager } from "../entity/MockEntitiesManager";
 import { MockObject } from "./MockObject";
 export interface IMockObjectCreateOptions extends IObjectCreateOptions {

package/dist/server/entities/mock/object/MockObjectsManager.js

@@ -4,7 +4,7 @@ exports.MockObjectsManager = void 0;
 const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
 const MockObject_1 = require("./MockObject");
 const RockMod_1 = require("../../../RockMod");
-const common_1 = require("../../common");
+const shared_1 = require("../../../../shared");
 class MockObjectsManager extends MockEntitiesManager_1.MockEntitiesManager {
     _nextId;
     constructor() {
@@ -17,7 +17,7 @@ class MockObjectsManager extends MockEntitiesManager_1.MockEntitiesManager {
         const { model, alpha, position, dimension, rotation } = options;
         const object = new MockObject_1.MockObject({
             id: this._nextId++,
-            type: common_1.BaseObjectType.Object,
+            type: shared_1.BaseObjectType.Object,
             model: RockMod_1.RockMod.instance.utils.hash(model),
             alpha,
             position,

package/dist/server/entities/mock/ped/MockPed.d.ts

@@ -1,5 +1,5 @@
-import { IPed } from "../../common/ped/IPed";
-import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+import { type IPed } from "../../common/ped/IPed";
+import { MockEntity, type IMockEntityOptions } from "../entity/MockEntity";
 export interface IMockPedOptions extends IMockEntityOptions {
 }
 export declare class MockPed extends MockEntity implements IPed {

package/dist/server/entities/mock/ped/MockPedsManager.d.ts

@@ -1,4 +1,4 @@
-import { IPedCreateOptions, IPedsManager } from "../../common/ped/IPedsManager";
+import { type IPedCreateOptions, type IPedsManager } from "../../common/ped/IPedsManager";
 import { MockEntitiesManager } from "../entity/MockEntitiesManager";
 import { MockPed } from "./MockPed";
 export interface IMockPedCreateOptions extends IPedCreateOptions {

package/dist/server/entities/mock/ped/MockPedsManager.js

@@ -4,7 +4,7 @@ exports.MockPedsManager = void 0;
 const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
 const MockPed_1 = require("./MockPed");
 const RockMod_1 = require("../../../RockMod");
-const common_1 = require("../../common");
+const shared_1 = require("../../../../shared");
 class MockPedsManager extends MockEntitiesManager_1.MockEntitiesManager {
     _nextId;
     constructor() {
@@ -17,7 +17,7 @@ class MockPedsManager extends MockEntitiesManager_1.MockEntitiesManager {
         const { model, position, dimension, rotation } = options;
         const ped = new MockPed_1.MockPed({
             id: this._nextId++,
-            type: common_1.BaseObjectType.Ped,
+            type: shared_1.BaseObjectType.Ped,
             model: RockMod_1.RockMod.instance.utils.hash(model),
             position,
             dimension,

package/dist/server/entities/mock/player/MockPlayer.d.ts

@@ -1,9 +1,9 @@
-import { IPlayer } from "../../common/player/IPlayer";
-import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
-import { Vector3D } from "../../../common/utils/math/Vectors";
-import { RageVehicle } from "../../ragemp/vehicle/RageVehicle";
-import { IMockClientEvents } from "../../../net/mock/events/MockEventsManager";
-import { IMockClientRPC } from "../../../net/mock/rpc/MockRPCManager";
+import { type IPlayer } from "../../common/player/IPlayer";
+import { MockEntity, type IMockEntityOptions } from "../entity/MockEntity";
+import { type Vector3D } from "../../../../shared/common/utils/math/Vectors";
+import { type RageVehicle } from "../../ragemp/vehicle/RageVehicle";
+import { type IMockClientRPC } from "../../../net/mock/rpc/MockRPCManager";
+import { type IServerToClientEvents } from "../../../../shared";
 export interface IMockPlayerOptions extends IMockEntityOptions {
     name?: string;
     socialClub?: string;
@@ -32,7 +32,7 @@ export declare class MockPlayer extends MockEntity implements IPlayer {
     get eyeColor(): number;
     get streamedPlayers(): MockPlayer[];
     constructor(options: IMockPlayerOptions);
-    emitEvent<K extends keyof IMockClientEvents>(eventName: K, ...args: Parameters<IMockClientEvents[K]>): void;
+    emitEvent<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
     emitRPC<K extends keyof IMockClientRPC>(rpcName: K, ...args: Parameters<IMockClientRPC[K]>): Promise<ReturnType<IMockClientRPC[K]>>;
     spawn(position: Vector3D): void;
     setName(name: string): void;

package/dist/server/entities/mock/player/MockPlayer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockPlayer = void 0;
 const MockEntity_1 = require("../entity/MockEntity");
 const RockMod_1 = require("../../../RockMod");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
 class MockPlayer extends MockEntity_1.MockEntity {
     _playerData;
     get name() {
@@ -79,10 +80,10 @@ class MockPlayer extends MockEntity_1.MockEntity {
         this._playerData.heading = value;
     }
     setHealth(value) {
-        this._playerData.health = Math.clamp(value, 0, 100);
+        this._playerData.health = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setArmour(value) {
-        this._playerData.armour = Math.clamp(value, 0, 100);
+        this._playerData.armour = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setWeaponAmmo(weapon, ammo) {
         this._playerData.weapon = RockMod_1.RockMod.instance.utils.hash(weapon);

package/dist/server/entities/mock/player/MockPlayersManager.d.ts

@@ -1,7 +1,7 @@
-import { IPlayersManager } from "../../common/player/IPlayersManager";
+import { type IPlayersManager } from "../../common/player/IPlayersManager";
 import { MockPlayer } from "./MockPlayer";
 import { MockEntitiesManager } from "../entity/MockEntitiesManager";
-import { Vector3D } from "../../../common/utils/math/Vectors";
+import { Vector3D } from "../../../../shared/common/utils/math/Vectors";
 export interface IMockPlayerConnectOptions {
     id?: number;
     name?: string;

package/dist/server/entities/mock/player/MockPlayersManager.js

@@ -4,8 +4,9 @@ exports.MockPlayersManager = void 0;
 const MockPlayer_1 = require("./MockPlayer");
 const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
 const RockMod_1 = require("../../../RockMod");
-const common_1 = require("../../common");
-const Vectors_1 = require("../../../common/utils/math/Vectors");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const shared_1 = require("../../../../shared");
+const types_1 = require("../../../net/common/events/types");
 class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
     _nextId;
     constructor() {
@@ -48,7 +49,7 @@ class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
         const { id = this._nextId++, name = `Player${id}`, socialClub = `Player${id}`, position = new Vectors_1.Vector3D(0, 0, 0), dimension = 0, health = 100, armour = 0, ip = "127.0.0.1", serial = `MOCK_${id}`, } = options;
         const player = new MockPlayer_1.MockPlayer({
             id,
-            type: common_1.BaseObjectType.Player,
+            type: shared_1.BaseObjectType.Player,
             name,
             socialClub,
             position,
@@ -65,14 +66,14 @@ class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
     }
     simulateConnect(options = {}) {
         const player = this.createPlayer(options);
-        RockMod_1.RockMod.instance.net.events.emit("rm::playerConnected", player);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerConnected, player);
         return player;
     }
     simulateDisconnect(player) {
         if (!this._baseObjects.has(player.id)) {
             throw new Error(`Player with id ${player.id} not found`);
         }
-        RockMod_1.RockMod.instance.net.events.emit("rm::playerDisconnected", player);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
         this.unregisterBaseObject(player);
     }
 }

package/dist/server/entities/mock/vehicle/MockVehicle.d.ts

@@ -1,7 +1,7 @@
-import { IVehicle } from "../../common/vehicle/IVehicle";
-import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
-import { RGBA } from "../../../common/utils";
-import { MockPlayer } from "../player/MockPlayer";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { MockEntity, type IMockEntityOptions } from "../entity/MockEntity";
+import { RGBA } from "../../../../shared/common/utils";
+import { type MockPlayer } from "../player/MockPlayer";
 export interface IMockVehicleOptions extends IMockEntityOptions {
     engine?: boolean;
     locked?: boolean;

package/dist/server/entities/mock/vehicle/MockVehicle.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockVehicle = void 0;
 const MockEntity_1 = require("../entity/MockEntity");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
 class MockVehicle extends MockEntity_1.MockEntity {
     _bodyHealth;
     _engineHealth;
@@ -71,7 +72,7 @@ class MockVehicle extends MockEntity_1.MockEntity {
         this._bodyHealth = value;
     }
     setEngineHealth(value) {
-        this._engineHealth = Math.clamp(value, 0, 1000);
+        this._engineHealth = (0, Math_1.MathClamp)(value, 0, 1000);
     }
     setNumberPlate(value) {
         this._numberPlate = value;

package/dist/server/entities/mock/vehicle/MockVehiclesManager.d.ts

@@ -1,4 +1,4 @@
-import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { type IVehicleCreateOptions, type IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
 import { MockEntitiesManager } from "../entity/MockEntitiesManager";
 import { MockVehicle } from "./MockVehicle";
 export interface IMockVehicleCreateOptions extends IVehicleCreateOptions {

package/dist/server/entities/mock/vehicle/MockVehiclesManager.js

@@ -4,7 +4,7 @@ exports.MockVehiclesManager = void 0;
 const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
 const MockVehicle_1 = require("./MockVehicle");
 const RockMod_1 = require("../../../RockMod");
-const common_1 = require("../../common");
+const shared_1 = require("../../../../shared");
 class MockVehiclesManager extends MockEntitiesManager_1.MockEntitiesManager {
     _nextId;
     constructor() {
@@ -17,7 +17,7 @@ class MockVehiclesManager extends MockEntitiesManager_1.MockEntitiesManager {
         const { model, engine, locked, position, dimension, rotation } = options;
         const vehicle = new MockVehicle_1.MockVehicle({
             id: this._nextId++,
-            type: common_1.BaseObjectType.Vehicle,
+            type: shared_1.BaseObjectType.Vehicle,
             model: RockMod_1.RockMod.instance.utils.hash(model),
             engine,
             locked,

package/dist/server/entities/mock/worldObject/MockWorldObject.d.ts

@@ -1,6 +1,6 @@
-import { IWorldObject } from "../../common/worldObject/IWorldObject";
-import { MockBaseObject, IMockBaseObjectOptions } from "../baseObject/MockBaseObject";
-import { IVector3D } from "../../../common/utils/math/Vectors";
+import { type IWorldObject } from "../../common/worldObject/IWorldObject";
+import { MockBaseObject, type IMockBaseObjectOptions } from "../baseObject/MockBaseObject";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
 export interface IMockWorldObjectOptions extends IMockBaseObjectOptions {
     position: IVector3D;
     dimension: number;

package/dist/server/entities/mock/worldObject/MockWorldObjectsIterator.d.ts

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

package/dist/server/entities/mock/worldObject/MockWorldObjectsManager.d.ts

@@ -1,6 +1,6 @@
-import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
-import { MockWorldObject } from "./MockWorldObject";
-import { IMockBaseObjectsManagerOptions, MockBaseObjectsManager } from "../baseObject/MockBaseObjectsManager";
+import { type IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { type MockWorldObject } from "./MockWorldObject";
+import { type IMockBaseObjectsManagerOptions, MockBaseObjectsManager } from "../baseObject/MockBaseObjectsManager";
 import { MockWorldObjectsIterator } from "./MockWorldObjectsIterator";
 export interface IMockWorldObjectsManagerOptions extends IMockBaseObjectsManagerOptions {
 }

package/dist/server/entities/ragemp/baseObject/RageBaseObject.d.ts

@@ -1,4 +1,5 @@
-import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+import { type IBaseObject, type IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+import { type BaseObjectType } from "../../../../shared";
 export interface IRageBaseObjectOptions<T extends EntityMp> extends IBaseObjectOptions {
     mpEntity: T;
 }

package/dist/server/entities/ragemp/baseObject/RageBaseObject.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObject = void 0;
 // RAGEMP BUG: event 'entityDestroyed' is not callable
-const unsupportedRageEntityTypes = new Set(["blip", "colshape", "object", "vehicle"]);
+const unsupportedRageEntityTypes = new Set(["blip", "colshape", "object", "ped", "vehicle"]);
 class RageBaseObject {
     _mpEntity;
     get id() {

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsIterator.d.ts

@@ -1,5 +1,5 @@
-import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
-import { RageBaseObject } from "./RageBaseObject";
+import { type IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { type RageBaseObject } from "./RageBaseObject";
 export declare class RageBaseObjectsIterator<T extends RageBaseObject> implements IBaseObjectsIterator<T> {
     private readonly _baseObjects;
     constructor(baseObjects: ReadonlyMap<number, T>);

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.d.ts

@@ -1,5 +1,5 @@
-import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
-import { RageBaseObject } from "./RageBaseObject";
+import { type IBaseObjectsManager, type IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { type RageBaseObject } from "./RageBaseObject";
 import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
 export interface IRageBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
 }

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObjectsManager = void 0;
 const RageBaseObjectsIterator_1 = require("./RageBaseObjectsIterator");
 const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
 class RageBaseObjectsManager {
     _baseObjects;
     _baseObjectsType;
@@ -40,13 +41,13 @@ class RageBaseObjectsManager {
             throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
         }
         this._baseObjects.set(baseObject.id, baseObject);
-        RockMod_1.RockMod.instance.net.events.emit("rm::entityCreated", baseObject);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
     }
     unregisterBaseObject(baseObject) {
         if (!this._baseObjects.delete(baseObject.id)) {
             throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
         }
-        RockMod_1.RockMod.instance.net.events.emit("rm::entityDestroyed", baseObject);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
     }
 }
 exports.RageBaseObjectsManager = RageBaseObjectsManager;

package/dist/server/entities/ragemp/blip/RageBlip.d.ts

@@ -1,5 +1,6 @@
-import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { IBlip, IBlipColor, IBlipSprite } from "../../common";
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { type IBlip } from "../../common";
+import { type IBlipColor, type IBlipSprite } from "../../../../shared";
 export interface IRageBlipOptions extends IRageWorldObjectOptions<EntityMp> {
 }
 export declare class RageBlip extends RageWorldObject<EntityMp> implements IBlip {

package/dist/server/entities/ragemp/blip/RageBlipsManager.d.ts

@@ -1,4 +1,4 @@
-import { IBlipCreateOptions, IBlipsManager } from "../../common";
+import { type IBlipCreateOptions, type IBlipsManager } from "../../common";
 import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
 import { RageBlip } from "./RageBlip";
 export interface IRageBlipCreateOptions extends IBlipCreateOptions {

package/dist/server/entities/ragemp/colshape/RageCircleColshape.d.ts

@@ -1,5 +1,5 @@
-import { IRageColshapeOptions, RageColshape } from "./RageColshape";
-import { ICircleColshape } from "../../common";
+import { type IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { type ICircleColshape } from "../../common";
 export interface IRageCircleColshapeOptions extends IRageColshapeOptions {
 }
 export declare class RageCircleColshape extends RageColshape implements ICircleColshape {

package/dist/server/entities/ragemp/colshape/RageColshape.d.ts

@@ -1,4 +1,4 @@
-import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
 export interface IRageColshapeOptions extends IRageWorldObjectOptions<ColshapeMp> {
 }
 export declare abstract class RageColshape extends RageWorldObject<ColshapeMp> {

package/dist/server/entities/ragemp/colshape/RageColshapesManager.d.ts

@@ -1,6 +1,6 @@
 import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
-import { RageColshape } from "./RageColshape";
-import { ICircleColshapeCreateOptions, IColshapesManager, ICuboidColshapeCreateOptions, ICylinderColshapeCreateOptions, IRectangleColshapeCreateOptions, ISphereColshapeCreateOptions } from "../../common";
+import { type RageColshape } from "./RageColshape";
+import { type ICircleColshapeCreateOptions, type IColshapesManager, type ICuboidColshapeCreateOptions, type ICylinderColshapeCreateOptions, type IRectangleColshapeCreateOptions, type ISphereColshapeCreateOptions } from "../../common";
 import { RageCircleColshape } from "./RageCircleColshape";
 import { RageCuboidColshape } from "./RageCuboidColshape";
 import { RageCylinderColshape } from "./RageCylinderColshape";

package/dist/server/entities/ragemp/colshape/RageCuboidColshape.d.ts

@@ -1,5 +1,5 @@
-import { IRageColshapeOptions, RageColshape } from "./RageColshape";
-import { ICuboidColshape } from "../../common";
+import { type IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { type ICuboidColshape } from "../../common";
 export interface IRageCuboidColshapeOptions extends IRageColshapeOptions {
 }
 export declare class RageCuboidColshape extends RageColshape implements ICuboidColshape {

package/dist/server/entities/ragemp/colshape/RageCylinderColshape.d.ts

@@ -1,5 +1,5 @@
-import { ICylinderColshape } from "../../common";
-import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { type ICylinderColshape } from "../../common";
+import { type IRageColshapeOptions, RageColshape } from "./RageColshape";
 export interface IRageCylinderColshapeOptions extends IRageColshapeOptions {
 }
 export declare class RageCylinderColshape extends RageColshape implements ICylinderColshape {

package/dist/server/entities/ragemp/colshape/RageRectangleColshape.d.ts

@@ -1,5 +1,5 @@
-import { IRectangleColshape } from "../../common";
-import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { type IRectangleColshape } from "../../common";
+import { type IRageColshapeOptions, RageColshape } from "./RageColshape";
 export interface IRageRectangleColshapeOptions extends IRageColshapeOptions {
 }
 export declare class RageRectangleColshape extends RageColshape implements IRectangleColshape {

package/dist/server/entities/ragemp/colshape/RageSphereColshape.d.ts

@@ -1,5 +1,5 @@
-import { ISphereColshape } from "../../common";
-import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { type ISphereColshape } from "../../common";
+import { type IRageColshapeOptions, RageColshape } from "./RageColshape";
 export interface IRageSphereColshapeOptions extends IRageColshapeOptions {
 }
 export declare class RageSphereColshape extends RageColshape implements ISphereColshape {

package/dist/server/entities/ragemp/entity/RageEntitiesManager.d.ts

@@ -1,6 +1,6 @@
-import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
-import { RageEntity } from "./RageEntity";
-import { IRageWorldObjectsManagerOptions, RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { type IEntitiesManager } from "../../common/entity/IEntitiesManager";
+import { type RageEntity } from "./RageEntity";
+import { type IRageWorldObjectsManagerOptions, RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
 export interface IRageEntitiesManagerOptions extends IRageWorldObjectsManagerOptions {
 }
 export declare abstract class RageEntitiesManager<T extends RageEntity<EntityMp>> extends RageWorldObjectsManager<T> implements IEntitiesManager<T> {

package/dist/server/entities/ragemp/entity/RageEntity.d.ts

@@ -1,6 +1,6 @@
-import { IEntity } from "../../common/entity/IEntity";
-import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { Vector3D } from "../../../common/utils";
+import { type IEntity } from "../../common/entity/IEntity";
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { Vector3D } from "../../../../shared/common/utils";
 export interface IRageEntityOptions<T extends EntityMp> extends IRageWorldObjectOptions<T> {
 }
 export declare abstract class RageEntity<T extends EntityMp> extends RageWorldObject<T> implements IEntity {

package/dist/server/entities/ragemp/entity/RageEntity.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageEntity = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 class RageEntity extends RageWorldObject_1.RageWorldObject {
     get model() {
         return this.mpEntity.model;

package/dist/server/entities/ragemp/marker/RageMarker.d.ts

@@ -1,6 +1,7 @@
-import { IMarker, IMarkerType } from "../../common";
-import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { IRGBA, IVector3D } from "../../../common/utils";
+import { type IMarker } from "../../common";
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { type IRGBA, type IVector3D } from "../../../../shared/common/utils";
+import { type IMarkerType } from "../../../../shared";
 export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
 }
 export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {

package/dist/server/entities/ragemp/marker/RageMarker.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMarker = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 class RageMarker extends RageWorldObject_1.RageWorldObject {
     get markerType() {
         return this.mpEntity.model;

package/dist/server/entities/ragemp/marker/RageMarkersManager.d.ts

@@ -1,4 +1,4 @@
-import { IMarkerCreateOptions, IMarkersManager } from "../../common";
+import { type IMarkerCreateOptions, type IMarkersManager } from "../../common";
 import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
 import { RageMarker } from "./RageMarker";
 export interface IRageMarkerCreateOptions extends IMarkerCreateOptions {

package/dist/server/entities/ragemp/marker/RageMarkersManager.js

@@ -16,7 +16,7 @@ class RageMarkersManager extends RageWorldObjectsManager_1.RageWorldObjectsManag
             dimension,
             rotation: new mp.Vector3(rotation),
         });
-        mpEntity.isExists = () => mp.objects.exists(mpEntity);
+        mpEntity.isExists = () => mp.markers.exists(mpEntity);
         const marker = new RageMarker_1.RageMarker({ mpEntity });
         this.registerBaseObject(marker);
         return marker;

package/dist/server/entities/ragemp/object/RageObject.d.ts

@@ -1,5 +1,5 @@
-import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { IObject } from "../../common/object/IObject";
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type IObject } from "../../common/object/IObject";
 export interface IRageObjectOptions extends IRageEntityOptions<ObjectMp> {
 }
 export declare class RageObject extends RageEntity<ObjectMp> implements IObject {

package/dist/server/entities/ragemp/object/RageObjectsManager.d.ts

@@ -1,4 +1,4 @@
-import { IObjectCreateOptions, IObjectsManager } from "../../common/object/IObjectsManager";
+import { type IObjectCreateOptions, type IObjectsManager } from "../../common/object/IObjectsManager";
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RageObject } from "./RageObject";
 export interface IRageObjectCreateOptions extends IObjectCreateOptions {

package/dist/server/entities/ragemp/ped/RagePed.d.ts

@@ -1,5 +1,5 @@
-import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { IPed } from "../../common";
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type IPed } from "../../common";
 export interface IRagePedOptions extends IRageEntityOptions<PedMp> {
 }
 export declare class RagePed extends RageEntity<PedMp> implements IPed {

package/dist/server/entities/ragemp/ped/RagePedsManager.d.ts

@@ -1,4 +1,4 @@
-import { IPedCreateOptions, IPedsManager } from "../../common";
+import { type IPedCreateOptions, type IPedsManager } from "../../common";
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RagePed } from "./RagePed";
 export interface IRagePedCreateOptions extends IPedCreateOptions {

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

@@ -1,9 +1,8 @@
-import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { ICustomization, IPlayer } from "../../common/player/IPlayer";
-import { RageVehicle } from "../vehicle/RageVehicle";
-import { Vector3D } from "../../../common/utils/math/Vectors";
-import { IRageClientEvents } from "../../../net/ragemp/events/RageEventsManager";
-import { IRageClientRPC } from "../../../net/ragemp/rpc/RageRPCManager";
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type ICustomization, type IPlayer } from "../../common/player/IPlayer";
+import { type RageVehicle } from "../vehicle/RageVehicle";
+import { type IServerToClientEvents, type Vector3D } from "../../../../shared";
+import { type IClientRPCList } from "../../../../shared/net/common/rpc/types";
 interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
 }
 export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
@@ -22,8 +21,8 @@ export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer
     get eyeColor(): number;
     get streamedPlayers(): RagePlayer[];
     constructor(options: IRagePlayerOptions);
-    emitEvent<K extends keyof IRageClientEvents>(eventName: K, ...args: Parameters<IRageClientEvents[K]>): void;
-    emitRPC<K extends keyof IRageClientRPC>(rpcName: K, ...args: Parameters<IRageClientRPC[K]>): Promise<ReturnType<IRageClientRPC[K]>>;
+    emitEvent<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
+    emitRPC<K extends keyof IClientRPCList>(rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
     spawn(position: Vector3D): void;
     setName(name: string): void;
     setHeading(value: number): void;