rock-mod 0.8.3 → 0.9.1

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

@@ -0,0 +1,6 @@
+import { RageEntity } from "../entity/RageEntity";
+export class RagePed extends RageEntity {
+    constructor(options) {
+        super(options);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type IPedCreateOptions, type 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/client/entities/ragemp/ped/RagePedsManager.js

@@ -0,0 +1,17 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RagePed } from "./RagePed";
+export class RagePedsManager extends RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "ped",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation } = options;
+        const mpEntity = mp.peds.new(mp.game.joaat(model), new mp.Vector3(position), rotation.z, dimension);
+        mpEntity.isExists = () => mp.peds.exists(mpEntity);
+        const ped = new RagePed({ mpEntity });
+        this.registerBaseObject(ped);
+        return ped;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type IPlayer } from "../../common/player/IPlayer";
+interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
+}
+export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
+    get name(): string;
+    get heading(): number;
+    get health(): number;
+    get armour(): number;
+    get isDead(): boolean;
+    constructor(options: IRagePlayerOptions);
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { RageEntity } from "../entity/RageEntity";
+export class RagePlayer extends RageEntity {
+    get name() {
+        return this.mpEntity.name;
+    }
+    get heading() {
+        return this.mpEntity.heading;
+    }
+    get health() {
+        return this.mpEntity.health;
+    }
+    get armour() {
+        return this.mpEntity.armour;
+    }
+    get isDead() {
+        return this.mpEntity.health <= 0;
+    }
+    constructor(options) {
+        super(options);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RagePlayer } from "./RagePlayer";
+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;
+    findByName(name: string): RagePlayer | null;
+    private _init;
+}

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

@@ -0,0 +1,43 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RagePlayer } from "./RagePlayer";
+import { ClientInternalEventName } from "@RockMod/client/net/common/events/types";
+export class RagePlayersManager extends RageEntitiesManager {
+    constructor(net) {
+        super({
+            baseObjectsType: "player",
+        });
+        this._init(net);
+    }
+    getByName(name) {
+        const player = this.findByName(name);
+        if (!player) {
+            throw new Error(`Player with name ${name} not found`);
+        }
+        return player;
+    }
+    findByName(name) {
+        for (const player of this.iterator.all()) {
+            if (player.name === name) {
+                return player;
+            }
+        }
+        return null;
+    }
+    _init(net) {
+        net.events.onInternal({
+            playerJoin: (mpPlayer) => {
+                mpPlayer.isExists = () => mp.players.exists(mpPlayer);
+                const player = new RagePlayer({
+                    mpEntity: mpPlayer,
+                });
+                this.registerBaseObject(player);
+                net.events.emitInternal(ClientInternalEventName.PlayerConnected, player);
+            },
+            playerQuit: (mpPlayer) => {
+                const player = this.getByID(mpPlayer.id);
+                this.unregisterBaseObject(player);
+                net.events.emitInternal(ClientInternalEventName.PlayerDisconnected, player);
+            },
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
+}
+export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehicle {
+    get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isDead(): boolean;
+    constructor(options: IRageVehicleOptions);
+    setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
+    explode(): void;
+}

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

@@ -0,0 +1,30 @@
+import { RageEntity } from "../entity/RageEntity";
+export class RageVehicle extends RageEntity {
+    get bodyHealth() {
+        return this.mpEntity.getBodyHealth();
+    }
+    get engineHealth() {
+        return this.mpEntity.getEngineHealth();
+    }
+    get numberPlate() {
+        return this.mpEntity.getNumberPlateText();
+    }
+    get isDead() {
+        return this.mpEntity.isDead();
+    }
+    constructor(options) {
+        super(options);
+    }
+    setBodyHealth(value) {
+        this.mpEntity.setBodyHealth(value);
+    }
+    setEngineHealth(value) {
+        this.mpEntity.setEngineHealth(value);
+    }
+    setNumberPlate(value) {
+        this.mpEntity.setNumberPlateText(value);
+    }
+    explode() {
+        return this.mpEntity.explode(true, true);
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RageVehicle } from "./RageVehicle";
+export class RageVehiclesManager extends RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation, engine, locked } = options;
+        const mpEntity = mp.vehicles.new(model, new mp.Vector3(position), {
+            dimension,
+            heading: rotation.z,
+            engine,
+            locked,
+        });
+        mpEntity.rotation = new mp.Vector3(rotation);
+        mpEntity.isExists = () => mp.vehicles.exists(mpEntity);
+        const vehicle = new RageVehicle({ mpEntity });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
+}

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

@@ -0,0 +1,12 @@
+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 {
+    get position(): Vector3D;
+    get dimension(): number;
+    protected constructor(options: IRageWorldObjectOptions<T>);
+    setPosition(value: Vector3D): void;
+    setDimension(value: number): void;
+}

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

@@ -0,0 +1,20 @@
+import { RageBaseObject } from "../baseObject/RageBaseObject";
+import { Vector3D } from "../../../../shared/common/utils/math/Vectors";
+export class RageWorldObject extends RageBaseObject {
+    get position() {
+        const { x, y, z } = this.mpEntity.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this.mpEntity.dimension;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setPosition(value) {
+        this.mpEntity.position = new mp.Vector3(value);
+    }
+    setDimension(value) {
+        this.mpEntity.dimension = value;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { type RageWorldObject } from "./RageWorldObject";
+import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
+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>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/client/entities/ragemp/worldObject/RageWorldObjectsIterator.js

@@ -0,0 +1,35 @@
+import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
+export class RageWorldObjectsIterator extends RageBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) + (center.y - position.y) * (center.y - position.y);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) +
+                (center.y - position.y) * (center.y - position.y) +
+                (center.z - position.z) * (center.z - position.z);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+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 {
+}
+export declare abstract class RageWorldObjectsManager<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: RageWorldObjectsIterator<T>;
+    get iterator(): RageWorldObjectsIterator<T>;
+    protected constructor(options: IRageWorldObjectsManagerOptions);
+}

package/dist/client/entities/ragemp/worldObject/RageWorldObjectsManager.js

@@ -0,0 +1,11 @@
+import { RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
+import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";
+export class RageWorldObjectsManager extends RageBaseObjectsManager {
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        super(options);
+        this._iterator = new RageWorldObjectsIterator(this.baseObjects);
+    }
+}

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

@@ -0,0 +1,14 @@
+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;
+    createColshapesManager(): IColshapesManager;
+    createMarkersManager(): IMarkersManager;
+    createObjectsManager(): IObjectsManager;
+    createPedsManager(): IPedsManager;
+    createPlayersManager(net: INetManager): IPlayersManager;
+    createUtilsManager(): IUtilsManager;
+    createVehiclesManager(): IVehiclesManager;
+}

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,38 @@
+import { RageBlipsManager } from "@RockMod/client/entities/ragemp/blip/RageBlipsManager";
+import { RageColshapesManager } from "@RockMod/client/entities/ragemp/colshape/RageColshapesManager";
+import { RageMarkersManager } from "@RockMod/client/entities/ragemp/marker/RageMarkersManager";
+import { RageObjectsManager } from "@RockMod/client/entities/ragemp/object/RageObjectsManager";
+import { RagePedsManager } from "@RockMod/client/entities/ragemp/ped/RagePedsManager";
+import { RagePlayersManager } from "@RockMod/client/entities/ragemp/player/RagePlayersManager";
+import { RageVehiclesManager } from "@RockMod/client/entities/ragemp/vehicle/RageVehiclesManager";
+import { RageNetManager } from "@RockMod/client/net/ragemp/RageNetManager";
+import { RageUtilsManager } from "@RockMod/client/utils/ragemp/RageUtilsManager";
+export class RageManagersFactory {
+    createNetManager() {
+        return new RageNetManager();
+    }
+    createBlipsManager() {
+        return new RageBlipsManager();
+    }
+    createColshapesManager() {
+        return new RageColshapesManager();
+    }
+    createMarkersManager() {
+        return new RageMarkersManager();
+    }
+    createObjectsManager() {
+        return new RageObjectsManager();
+    }
+    createPedsManager() {
+        return new RagePedsManager();
+    }
+    createPlayersManager(net) {
+        return new RagePlayersManager(net);
+    }
+    createUtilsManager() {
+        return new RageUtilsManager();
+    }
+    createVehiclesManager() {
+        return new RageVehiclesManager();
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+import { RockMod } from "./RockMod";
+export { RockMod };

package/dist/client/index.js

@@ -1 +1,2 @@
-"use strict";
+import { RockMod } from "./RockMod";
+export { RockMod };

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { type IServerToClientEvents, type IClientToServerEvents } from "@shared/net/common/events/types";
+import { type IClientInternalEvents } from "./types";
+export interface IEventsManager {
+    onInternal(events: Partial<IClientInternalEvents>): void;
+    offInternal<K extends keyof IClientInternalEvents>(eventName: K, listener: IClientInternalEvents[K]): void;
+    emitInternal<K extends keyof IClientInternalEvents>(eventName: K, ...args: Parameters<IClientInternalEvents[K]>): void;
+    onServer(events: Partial<IServerToClientEvents>): void;
+    offServer<K extends keyof IServerToClientEvents>(eventName: K, listener: IServerToClientEvents[K]): void;
+    emitServer<K extends keyof IClientToServerEvents>(eventName: K, ...args: Parameters<IClientToServerEvents[K]>): void;
+}

package/dist/client/net/common/events/IEventsManager.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,7 @@
+export var ClientInternalEventName;
+(function (ClientInternalEventName) {
+    ClientInternalEventName["PlayerConnected"] = "rm::playerConnected";
+    ClientInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
+    ClientInternalEventName["EntityCreated"] = "rm::entityCreated";
+    ClientInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
+})(ClientInternalEventName || (ClientInternalEventName = {}));

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

@@ -0,0 +1,6 @@
+import { type IClientRPCList, type IServerRPCList } from "@shared/net/common/rpc/types";
+export interface IRPCManager {
+    register<K extends keyof IClientRPCList>(rpcName: K, handler: (...args: Parameters<IClientRPCList[K]>) => ReturnType<IClientRPCList[K]>): void;
+    unregister<K extends keyof IClientRPCList>(rpcName: K): void;
+    emitServer<K extends keyof IServerRPCList>(rpcName: K, ...args: Parameters<IServerRPCList[K]>): Promise<ReturnType<IServerRPCList[K]>>;
+}

package/dist/client/net/common/rpc/IRPCManager.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/client/net/ragemp/RageNetManager.js

@@ -0,0 +1,14 @@
+import { RageEventsManager } from "./events/RageEventsManager";
+import { RageRPCManager } from "./rpc/RageRPCManager";
+export class RageNetManager {
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new RageEventsManager();
+        this._rpcManager = new RageRPCManager();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { type IEventsManager } from "../../common/events/IEventsManager";
+import { type IClientInternalEvents } from "@RockMod/client/net/common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "@shared/net/common/events/types";
+interface IRageClientInternalEvents extends IClientInternalEvents, IClientEvents {
+}
+export declare class RageEventsManager implements IEventsManager {
+    onInternal(events: Partial<IRageClientInternalEvents>): void;
+    offInternal<K extends keyof IRageClientInternalEvents>(eventName: K, listener: IRageClientInternalEvents[K]): void;
+    emitInternal<K extends keyof IRageClientInternalEvents>(eventName: K, ...args: Parameters<IRageClientInternalEvents[K]>): void;
+    onServer(events: Partial<IServerToClientEvents>): void;
+    offServer<K extends keyof IServerToClientEvents>(eventName: K, listener: IServerToClientEvents[K]): void;
+    emitServer<K extends keyof IClientToServerEvents>(eventName: K, ...args: Parameters<IClientToServerEvents[K]>): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+export class RageEventsManager {
+    onInternal(events) {
+        mp.events.add(events);
+    }
+    offInternal(eventName, listener) {
+        return mp.events.remove(eventName, listener);
+    }
+    emitInternal(eventName, ...args) {
+        return mp.events.call(eventName, ...args);
+    }
+    onServer(events) {
+        return mp.events.add(events);
+    }
+    offServer(eventName, listener) {
+        return mp.events.remove(eventName, listener);
+    }
+    emitServer(eventName, ...args) {
+        return mp.events.callRemote(eventName, ...args);
+    }
+}

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

@@ -0,0 +1,7 @@
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type IClientRPCList, type IServerRPCList } from "@shared/net/common/rpc/types";
+export declare class RageRPCManager implements IRPCManager {
+    register<K extends keyof IClientRPCList>(rpcName: K, handler: (...args: Parameters<IClientRPCList[K]>) => ReturnType<IClientRPCList[K]>): void;
+    unregister<K extends keyof IClientRPCList>(rpcName: K): void;
+    emitServer<K extends keyof IServerRPCList>(rpcName: K, ...args: Parameters<IServerRPCList[K]>): Promise<ReturnType<IServerRPCList[K]>>;
+}

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

@@ -0,0 +1,11 @@
+export class RageRPCManager {
+    register(rpcName, handler) {
+        return mp.events.addProc(rpcName, handler);
+    }
+    unregister(rpcName) {
+        return mp.events.remove(rpcName);
+    }
+    emitServer(rpcName, ...args) {
+        return mp.events.callRemoteProc(rpcName, ...args);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

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

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

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

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

package/dist/client/utils/index.js

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

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

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

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

@@ -0,0 +1,5 @@
+export class RageUtilsManager {
+    hash(value) {
+        return mp.game.joaat(value);
+    }
+}

package/dist/server/RockMod.d.ts

@@ -1,7 +1,7 @@
-import { INetManager } from "./net/common/INetManager";
-import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
-import { IUtilsManager } from "./utils";
-import { IManagersFactory } from "./factories/common/IManagersFactory";
+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";
+import { type IManagersFactory } from "./factories/common/IManagersFactory";
 type MultiplayerType = "RageMP" | "AltV" | "Mock";
 export interface RockModOptions {
     multiplayer: MultiplayerType;

package/dist/server/entities/altv/baseObject/AltVBaseObject.d.ts

@@ -1,5 +1,6 @@
-import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+import { type IBaseObject, type IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
 import BaseObject = AltVServer.BaseObject;
+import { BaseObjectType } from "../../../../shared";
 export interface IAltVBaseObjectOptions<T extends BaseObject> extends IBaseObjectOptions {
     mpEntity: T;
 }