rock-mod 0.2.0 → 0.5.0

package/dist/server/entities/ragemp/colshape/RageColshapesManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageColshapesManager = void 0;
+const RageWorldObjectsManager_1 = require("../worldObject/RageWorldObjectsManager");
+const RageCircleColshape_1 = require("./RageCircleColshape");
+const RageCuboidColshape_1 = require("./RageCuboidColshape");
+const RageCylinderColshape_1 = require("./RageCylinderColshape");
+const RageRectangleColshape_1 = require("./RageRectangleColshape");
+const RageSphereColshape_1 = require("./RageSphereColshape");
+class RageColshapesManager extends RageWorldObjectsManager_1.RageWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "colshape",
+        });
+    }
+    createCircle(options) {
+        const { range, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = mp.colshapes.newCircle(x, y, range, dimension);
+        mpEntity.isExists = () => mp.colshapes.exists(mpEntity);
+        const colshape = new RageCircleColshape_1.RageCircleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { width, depth, height, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = mp.colshapes.newCuboid(x, y, z, width, depth, height, dimension);
+        mpEntity.isExists = () => mp.colshapes.exists(mpEntity);
+        const colshape = new RageCuboidColshape_1.RageCuboidColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { height, range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = mp.colshapes.newTube(x, y, z, height, range, dimension);
+        mpEntity.isExists = () => mp.colshapes.exists(mpEntity);
+        const colshape = new RageCylinderColshape_1.RageCylinderColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(options) {
+        const { width, height, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = mp.colshapes.newRectangle(x, y, width, height, dimension);
+        mpEntity.isExists = () => mp.colshapes.exists(mpEntity);
+        const colshape = new RageRectangleColshape_1.RageRectangleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createSphere(options) {
+        const { range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = mp.colshapes.newSphere(x, y, z, range, dimension);
+        mpEntity.isExists = () => mp.colshapes.exists(mpEntity);
+        const colshape = new RageSphereColshape_1.RageSphereColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}
+exports.RageColshapesManager = RageColshapesManager;

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

@@ -0,0 +1,7 @@
+import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+import { ICuboidColshape } from "../../common";
+export interface IRageCuboidColshapeOptions extends IRageColshapeOptions {
+}
+export declare class RageCuboidColshape extends RageColshape implements ICuboidColshape {
+    constructor(options: IRageCuboidColshapeOptions);
+}

package/dist/server/entities/ragemp/colshape/RageCuboidColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageCuboidColshape = void 0;
+const RageColshape_1 = require("./RageColshape");
+class RageCuboidColshape extends RageColshape_1.RageColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RageCuboidColshape = RageCuboidColshape;

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

@@ -0,0 +1,7 @@
+import { ICylinderColshape } from "../../common";
+import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+export interface IRageCylinderColshapeOptions extends IRageColshapeOptions {
+}
+export declare class RageCylinderColshape extends RageColshape implements ICylinderColshape {
+    constructor(options: IRageCylinderColshapeOptions);
+}

package/dist/server/entities/ragemp/colshape/RageCylinderColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageCylinderColshape = void 0;
+const RageColshape_1 = require("./RageColshape");
+class RageCylinderColshape extends RageColshape_1.RageColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RageCylinderColshape = RageCylinderColshape;

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

@@ -0,0 +1,7 @@
+import { IRectangleColshape } from "../../common";
+import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+export interface IRageRectangleColshapeOptions extends IRageColshapeOptions {
+}
+export declare class RageRectangleColshape extends RageColshape implements IRectangleColshape {
+    constructor(options: IRageRectangleColshapeOptions);
+}

package/dist/server/entities/ragemp/colshape/RageRectangleColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageRectangleColshape = void 0;
+const RageColshape_1 = require("./RageColshape");
+class RageRectangleColshape extends RageColshape_1.RageColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RageRectangleColshape = RageRectangleColshape;

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

@@ -0,0 +1,7 @@
+import { ISphereColshape } from "../../common";
+import { IRageColshapeOptions, RageColshape } from "./RageColshape";
+export interface IRageSphereColshapeOptions extends IRageColshapeOptions {
+}
+export declare class RageSphereColshape extends RageColshape implements ISphereColshape {
+    constructor(options: IRageSphereColshapeOptions);
+}

package/dist/server/entities/ragemp/colshape/RageSphereColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageSphereColshape = void 0;
+const RageColshape_1 = require("./RageColshape");
+class RageSphereColshape extends RageColshape_1.RageColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RageSphereColshape = RageSphereColshape;

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

@@ -0,0 +1,11 @@
+import { IMarker } from "../../common";
+import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
+}
+export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {
+    get visible(): boolean;
+    get scale(): number;
+    constructor(options: IRageMarkerOptions);
+    setVisible(value: boolean): void;
+    setScale(value: number): void;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMarker = void 0;
+const RageWorldObject_1 = require("../worldObject/RageWorldObject");
+class RageMarker extends RageWorldObject_1.RageWorldObject {
+    get visible() {
+        return this.mpEntity.visible;
+    }
+    get scale() {
+        return this.mpEntity.scale;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setVisible(value) {
+        this.mpEntity.visible = value;
+    }
+    setScale(value) {
+        this.mpEntity.scale = value;
+    }
+}
+exports.RageMarker = RageMarker;

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

@@ -0,0 +1,9 @@
+import { IMarkerCreateOptions, IMarkersManager } from "../../common";
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { RageMarker } from "./RageMarker";
+export interface IRageMarkerCreateOptions extends IMarkerCreateOptions {
+}
+export declare class RageMarkersManager extends RageWorldObjectsManager<RageMarker> implements IMarkersManager {
+    constructor();
+    create(options: IRageMarkerCreateOptions): RageMarker;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMarkersManager = void 0;
+const RageWorldObjectsManager_1 = require("../worldObject/RageWorldObjectsManager");
+const RageMarker_1 = require("./RageMarker");
+class RageMarkersManager extends RageWorldObjectsManager_1.RageWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "marker",
+        });
+    }
+    create(options) {
+        const { type, scale, color, position, dimension, rotation } = options;
+        const mpEntity = mp.markers.new(type, new mp.Vector3(position), scale, {
+            color: [color.r, color.g, color.b, color.a || 255],
+            dimension,
+            rotation: new mp.Vector3(rotation),
+        });
+        mpEntity.isExists = () => mp.objects.exists(mpEntity);
+        const marker = new RageMarker_1.RageMarker({ mpEntity });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}
+exports.RageMarkersManager = RageMarkersManager;

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

@@ -0,0 +1,9 @@
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { IObject } from "../../common/object/IObject";
+export interface IRageObjectOptions extends IRageEntityOptions<ObjectMp> {
+}
+export declare class RageObject extends RageEntity<ObjectMp> implements IObject {
+    get alpha(): number;
+    constructor(options: IRageObjectOptions);
+    setAlpha(value: number): void;
+}

package/dist/server/entities/ragemp/object/RageObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageObject = void 0;
+const RageEntity_1 = require("../entity/RageEntity");
+class RageObject extends RageEntity_1.RageEntity {
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+}
+exports.RageObject = RageObject;

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

@@ -0,0 +1,9 @@
+import { IObjectCreateOptions, IObjectsManager } from "../../common/object/IObjectsManager";
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RageObject } from "./RageObject";
+export interface IRageObjectCreateOptions extends IObjectCreateOptions {
+}
+export declare class RageObjectsManager extends RageEntitiesManager<RageObject> implements IObjectsManager {
+    constructor();
+    create(options: IRageObjectCreateOptions): RageObject;
+}

package/dist/server/entities/ragemp/object/RageObjectsManager.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageObjectsManager = void 0;
+const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RageObject_1 = require("./RageObject");
+class RageObjectsManager extends RageEntitiesManager_1.RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "object",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation, alpha } = options;
+        const mpEntity = mp.objects.new(model, new mp.Vector3(position), {
+            dimension,
+            rotation: new mp.Vector3(rotation),
+            alpha,
+        });
+        mpEntity.isExists = () => mp.objects.exists(mpEntity);
+        const object = new RageObject_1.RageObject({ mpEntity });
+        this.registerBaseObject(object);
+        return object;
+    }
+}
+exports.RageObjectsManager = RageObjectsManager;

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

@@ -0,0 +1,7 @@
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { IPed } from "../../common";
+export interface IRagePedOptions extends IRageEntityOptions<PedMp> {
+}
+export declare class RagePed extends RageEntity<PedMp> implements IPed {
+    constructor(options: IRagePedOptions);
+}

package/dist/server/entities/ragemp/ped/RagePed.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RagePed = void 0;
+const RageEntity_1 = require("../entity/RageEntity");
+class RagePed extends RageEntity_1.RageEntity {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RagePed = RagePed;

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

@@ -0,0 +1,9 @@
+import { IPedCreateOptions, IPedsManager } from "../../common";
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RagePed } from "./RagePed";
+export interface IRagePedCreateOptions extends IPedCreateOptions {
+}
+export declare class RagePedsManager extends RageEntitiesManager<RagePed> implements IPedsManager {
+    constructor();
+    create(options: IRagePedCreateOptions): RagePed;
+}

package/dist/server/entities/ragemp/ped/RagePedsManager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RagePedsManager = void 0;
+const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RagePed_1 = require("./RagePed");
+class RagePedsManager extends RageEntitiesManager_1.RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "ped",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation } = options;
+        const mpEntity = mp.peds.new(mp.joaat(model), new mp.Vector3(position), {
+            dimension,
+            heading: rotation.z,
+        });
+        mpEntity.isExists = () => mp.peds.exists(mpEntity);
+        const ped = new RagePed_1.RagePed({ mpEntity });
+        this.registerBaseObject(ped);
+        return ped;
+    }
+}
+exports.RagePedsManager = RagePedsManager;

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

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

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

@@ -5,11 +5,11 @@ const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
 const RagePlayer_1 = require("./RagePlayer");
 const RockMod_1 = require("../../../RockMod");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
-    constructor() {
+    constructor(net) {
         super({
             baseObjectsType: "player",
         });
-        this._init();
+        this._init(net);
     }
     getByName(name) {
         const player = this.findByName(name);
@@ -41,8 +41,7 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         }
         return null;
     }
-    _init() {
-        const net = RockMod_1.RockMod.instance.net;
+    _init(net) {
         net.events.on({
             playerJoin: (mpPlayer) => {
                 mpPlayer.isExists = () => mp.players.exists(mpPlayer);

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

@@ -18,6 +18,7 @@ class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
             locked,
         });
         mpEntity.rotation = new mp.Vector3(rotation);
+        mpEntity.isExists = () => mp.vehicles.exists(mpEntity);
         const vehicle = new RageVehicle_1.RageVehicle({ mpEntity });
         this.registerBaseObject(vehicle);
         return vehicle;

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

@@ -1,4 +1,4 @@
-import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { IWorldObjectsManager } from "../../common";
 import { IRageBaseObjectsManagerOptions, RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
 import { RageWorldObject } from "./RageWorldObject";
 import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";

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

@@ -1,9 +1,21 @@
 import { IManagersFactory } from "../common/IManagersFactory";
 import { AltVNetManager } from "../../net/altv/AltVNetManager";
+import { AltVBlipsManager } from "../../entities/altv/blip/AltVBlipsManager";
+import { AltVColshapesManager } from "../../entities/altv/colshape/AltVColshapesManager";
+import { AltVMarkersManager } from "../../entities/altv/marker/AltVMarkersManager";
+import { AltVObjectsManager } from "../../entities/altv/object/AltVObjectsManager";
+import { AltVPedsManager } from "../../entities/altv/ped/AltVPedsManager";
 import { AltVPlayersManager } from "../../entities/altv/player/AltVPlayersManager";
+import { AltVUtilsManager } from "../../utils/altv/AltVUtilsManager";
 import { AltVVehiclesManager } from "../../entities/altv/vehicle/AltVVehiclesManager";
 export declare class AltVManagersFactory implements IManagersFactory {
     createNetManager(): AltVNetManager;
+    createBlipsManager(): AltVBlipsManager;
+    createColshapesManager(): AltVColshapesManager;
+    createMarkersManager(): AltVMarkersManager;
+    createObjectsManager(): AltVObjectsManager;
+    createPedsManager(): AltVPedsManager;
     createPlayersManager(): AltVPlayersManager;
+    createUtilsManager(): AltVUtilsManager;
     createVehiclesManager(): AltVVehiclesManager;
 }

package/dist/server/factories/altv/AltVManagersFactory.js

@@ -2,15 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVManagersFactory = void 0;
 const AltVNetManager_1 = require("../../net/altv/AltVNetManager");
+const AltVBlipsManager_1 = require("../../entities/altv/blip/AltVBlipsManager");
+const AltVColshapesManager_1 = require("../../entities/altv/colshape/AltVColshapesManager");
+const AltVMarkersManager_1 = require("../../entities/altv/marker/AltVMarkersManager");
+const AltVObjectsManager_1 = require("../../entities/altv/object/AltVObjectsManager");
+const AltVPedsManager_1 = require("../../entities/altv/ped/AltVPedsManager");
 const AltVPlayersManager_1 = require("../../entities/altv/player/AltVPlayersManager");
+const AltVUtilsManager_1 = require("../../utils/altv/AltVUtilsManager");
 const AltVVehiclesManager_1 = require("../../entities/altv/vehicle/AltVVehiclesManager");
 class AltVManagersFactory {
     createNetManager() {
         return new AltVNetManager_1.AltVNetManager();
     }
+    createBlipsManager() {
+        return new AltVBlipsManager_1.AltVBlipsManager();
+    }
+    createColshapesManager() {
+        return new AltVColshapesManager_1.AltVColshapesManager();
+    }
+    createMarkersManager() {
+        return new AltVMarkersManager_1.AltVMarkersManager();
+    }
+    createObjectsManager() {
+        return new AltVObjectsManager_1.AltVObjectsManager();
+    }
+    createPedsManager() {
+        return new AltVPedsManager_1.AltVPedsManager();
+    }
     createPlayersManager() {
         return new AltVPlayersManager_1.AltVPlayersManager();
     }
+    createUtilsManager() {
+        return new AltVUtilsManager_1.AltVUtilsManager();
+    }
     createVehiclesManager() {
         return new AltVVehiclesManager_1.AltVVehiclesManager();
     }

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

@@ -1,8 +1,14 @@
 import { INetManager } from "../../net/common/INetManager";
-import { IPlayersManager } from "../../entities/common/player/IPlayersManager";
-import { IVehiclesManager } from "../../entities/common/vehicle/IVehiclesManager";
+import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "../../entities";
+import { IUtilsManager } from "../../utils";
 export interface IManagersFactory {
     createNetManager(): INetManager;
-    createPlayersManager(): IPlayersManager;
+    createBlipsManager(): IBlipsManager;
+    createColshapesManager(): IColshapesManager;
+    createMarkersManager(): IMarkersManager;
+    createObjectsManager(): IObjectsManager;
+    createPedsManager(): IPedsManager;
+    createPlayersManager(net: INetManager): IPlayersManager;
+    createUtilsManager(): IUtilsManager;
     createVehiclesManager(): IVehiclesManager;
 }

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

@@ -1,9 +1,21 @@
 import { IManagersFactory } from "../common/IManagersFactory";
 import { RageNetManager } from "../../net/ragemp/RageNetManager";
+import { RageBlipsManager } from "../../entities/ragemp/blip/RageBlipsManager";
+import { RageColshapesManager } from "../../entities/ragemp/colshape/RageColshapesManager";
+import { RageMarkersManager } from "../../entities/ragemp/marker/RageMarkersManager";
+import { RageObjectsManager } from "../../entities/ragemp/object/RageObjectsManager";
+import { RagePedsManager } from "../../entities/ragemp/ped/RagePedsManager";
 import { RagePlayersManager } from "../../entities/ragemp/player/RagePlayersManager";
+import { RageUtilsManager } from "../../utils/ragemp/RageUtilsManager";
 import { RageVehiclesManager } from "../../entities/ragemp/vehicle/RageVehiclesManager";
 export declare class RageManagersFactory implements IManagersFactory {
     createNetManager(): RageNetManager;
-    createPlayersManager(): RagePlayersManager;
+    createBlipsManager(): RageBlipsManager;
+    createColshapesManager(): RageColshapesManager;
+    createMarkersManager(): RageMarkersManager;
+    createObjectsManager(): RageObjectsManager;
+    createPedsManager(): RagePedsManager;
+    createPlayersManager(net: RageNetManager): RagePlayersManager;
+    createUtilsManager(): RageUtilsManager;
     createVehiclesManager(): RageVehiclesManager;
 }

package/dist/server/factories/ragemp/RageManagersFactory.js

@@ -2,14 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageManagersFactory = void 0;
 const RageNetManager_1 = require("../../net/ragemp/RageNetManager");
+const RageBlipsManager_1 = require("../../entities/ragemp/blip/RageBlipsManager");
+const RageColshapesManager_1 = require("../../entities/ragemp/colshape/RageColshapesManager");
+const RageMarkersManager_1 = require("../../entities/ragemp/marker/RageMarkersManager");
+const RageObjectsManager_1 = require("../../entities/ragemp/object/RageObjectsManager");
+const RagePedsManager_1 = require("../../entities/ragemp/ped/RagePedsManager");
 const RagePlayersManager_1 = require("../../entities/ragemp/player/RagePlayersManager");
+const RageUtilsManager_1 = require("../../utils/ragemp/RageUtilsManager");
 const RageVehiclesManager_1 = require("../../entities/ragemp/vehicle/RageVehiclesManager");
 class RageManagersFactory {
     createNetManager() {
         return new RageNetManager_1.RageNetManager();
     }
-    createPlayersManager() {
-        return new RagePlayersManager_1.RagePlayersManager();
+    createBlipsManager() {
+        return new RageBlipsManager_1.RageBlipsManager();
+    }
+    createColshapesManager() {
+        return new RageColshapesManager_1.RageColshapesManager();
+    }
+    createMarkersManager() {
+        return new RageMarkersManager_1.RageMarkersManager();
+    }
+    createObjectsManager() {
+        return new RageObjectsManager_1.RageObjectsManager();
+    }
+    createPedsManager() {
+        return new RagePedsManager_1.RagePedsManager();
+    }
+    createPlayersManager(net) {
+        return new RagePlayersManager_1.RagePlayersManager(net);
+    }
+    createUtilsManager() {
+        return new RageUtilsManager_1.RageUtilsManager();
     }
     createVehiclesManager() {
         return new RageVehiclesManager_1.RageVehiclesManager();

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

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

package/dist/server/utils/altv/AltVUtilsManager.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVUtilsManager = void 0;
+class AltVUtilsManager {
+    hash(value) {
+        return AltVShared.hash(value);
+    }
+}
+exports.AltVUtilsManager = AltVUtilsManager;

package/dist/server/utils/common/IUtilsManager.d.ts

@@ -0,0 +1,3 @@
+export interface IUtilsManager {
+    hash(value: string): number;
+}

package/dist/server/utils/common/IUtilsManager.js

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

package/dist/server/utils/common/index.d.ts

@@ -0,0 +1 @@
+export * from "./IUtilsManager";

package/dist/server/utils/common/index.js

@@ -0,0 +1,17 @@
+"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("./IUtilsManager"), exports);

package/dist/server/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./common";

package/dist/server/utils/index.js

@@ -0,0 +1,17 @@
+"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("./common"), exports);

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

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

package/dist/server/utils/ragemp/RageUtilsManager.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageUtilsManager = void 0;
+class RageUtilsManager {
+    hash(value) {
+        return mp.joaat(value);
+    }
+}
+exports.RageUtilsManager = RageUtilsManager;