rock-mod 0.17.0 → 0.18.0

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

@@ -1,11 +1,10 @@
 import { RageEntity } from "../entity/RageEntity";
+import { RockMod } from "../../../RockMod";
+import { Vector3D } from "../../../../shared/common/utils";
 export class RagePlayer extends RageEntity {
     get name() {
         return this.mpEntity.name;
     }
-    get heading() {
-        return this.mpEntity.heading;
-    }
     get health() {
         return this.mpEntity.health;
     }
@@ -18,4 +17,107 @@ export class RagePlayer extends RageEntity {
     constructor(options) {
         super(options);
     }
+    get vehicle() {
+        const vehicle = this.mpEntity.vehicle;
+        if (!vehicle) {
+            return null;
+        }
+        return RockMod.instance.vehicles.getByID(vehicle.id);
+    }
+    get isVoice3DEnabled() {
+        return Boolean(this.mpEntity.voice3d);
+    }
+    get voiceVolume() {
+        return this.mpEntity.voiceVolume;
+    }
+    get isVoiceActive() {
+        return this.mpEntity.isVoiceActive;
+    }
+    setVoice3D(enable) {
+        this.mpEntity.voice3d = enable;
+    }
+    setVoiceVolume(volume) {
+        this.mpEntity.voiceVolume = volume;
+    }
+    get isReloading() {
+        return this.mpEntity.isReloading();
+    }
+    get weapon() {
+        return this.mpEntity.weapon;
+    }
+    getAmmoInClip(weapon) {
+        return this.mpEntity.getAmmoInClip(weapon);
+    }
+    getWeaponAmmo(weapon) {
+        return mp.game.weapon.getAmmoInPed(this.mpEntity.handle, weapon);
+    }
+    getBoneIndex(boneId) {
+        return this.mpEntity.getBoneIndex(boneId);
+    }
+    setDecoration(collection, overlay) {
+        const collectionHash = mp.game.joaat(collection);
+        const overlayHash = mp.game.joaat(overlay);
+        this.mpEntity.setDecoration(collectionHash, overlayHash);
+    }
+    removeDecoration(collection, overlay) {
+        const collectionHash = mp.game.joaat(collection);
+        const overlayHash = mp.game.joaat(overlay);
+        // @ts-expect-error TODO test if this works
+        this.mpEntity.removeDecoration(collectionHash, overlayHash);
+    }
+    clearDecorations() {
+        this.mpEntity.clearDecorations();
+    }
+    setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent) {
+        this.mpEntity.setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent);
+    }
+    setFaceFeature(index, value) {
+        this.mpEntity.setFaceFeature(index, value);
+    }
+    setHeadOverlay(overlayId, index, opacity, firstColor, secondColor) {
+        this.mpEntity.setHeadOverlay(overlayId, index, opacity, firstColor, secondColor);
+    }
+    setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor) {
+        this.mpEntity.setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor);
+    }
+    setEyeColor(eyeColor) {
+        this.mpEntity.setEyeColor(eyeColor);
+    }
+    setHairColor(colorId, highlightColorId) {
+        this.mpEntity.setHairColor(colorId, highlightColorId);
+    }
+    setComponentVariation(componentId, drawableId, textureId, paletteId) {
+        this.mpEntity.setComponentVariation(componentId, drawableId, textureId, paletteId);
+    }
+    setPropertyVariation(componentId, drawableId, textureId, attach) {
+        this.mpEntity.setPropIndex(componentId, drawableId, textureId, attach);
+    }
+    clearProp(componentId) {
+        this.mpEntity.clearProp(componentId);
+    }
+    get isLocalPlayer() {
+        return mp.players.local.id === this.mpEntity.id;
+    }
+    clearTasks() {
+        this.mpEntity.clearTasks();
+    }
+    resetMovementClipset(blendDuration) {
+        this.mpEntity.resetMovementClipset(blendDuration);
+    }
+    setMovementClipset(clipset, speed) {
+        this.mpEntity.setMovementClipset(clipset, speed);
+    }
+    taskEnterVehicle(vehicleHandle, timeout, seat, speed, flag, p6) {
+        this.mpEntity.taskEnterVehicle(vehicleHandle, timeout, seat, speed, flag, p6);
+    }
+    taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ) {
+        this.mpEntity.taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ);
+    }
+    taskSwapWeapon() {
+        this.mpEntity.taskSwapWeapon(true);
+    }
+    getBoneCoords(boneId, offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this.mpEntity.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
 }

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

@@ -1,10 +1,12 @@
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RagePlayer } from "./RagePlayer";
-import { type IPlayersManager } from "../../common/player/IPlayersManager";
-import { type RageNetManager } from "../../../net/ragemp/RageNetManager";
+import { type IPlayer, type IPlayersManager } from "../../common";
 export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer> implements IPlayersManager {
-    constructor(net: RageNetManager);
+    constructor();
     getByName(name: string): RagePlayer;
     findByName(name: string): RagePlayer | null;
-    private _init;
+    findLocalPlayer(): RagePlayer | null;
+    getLocalPlayer(): IPlayer;
+    syncWithMpPool(): void;
+    registerById(id: number): RagePlayer;
 }

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

@@ -1,12 +1,10 @@
 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) {
+    constructor() {
         super({
             baseObjectsType: "player",
         });
-        this._init(net);
     }
     getByName(name) {
         const player = this.findByName(name);
@@ -23,21 +21,32 @@ export class RagePlayersManager extends RageEntitiesManager {
         }
         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);
-            },
+    findLocalPlayer() {
+        return this.findByID(mp.players.local.id);
+    }
+    getLocalPlayer() {
+        const localPlayer = this.findLocalPlayer();
+        if (!localPlayer) {
+            throw new Error(`Local player with id ${mp.players.local.id} not found`);
+        }
+        return localPlayer;
+    }
+    syncWithMpPool() {
+        for (const mpPlayer of mp.players.toArray()) {
+            this.registerById(mpPlayer.id);
+        }
+    }
+    registerById(id) {
+        const existingPlayer = this.findByID(id);
+        if (existingPlayer) {
+            return existingPlayer;
+        }
+        const mpPlayer = mp.players.at(id);
+        mpPlayer.isExists = () => mp.players.exists(mpPlayer);
+        const player = new RagePlayer({
+            mpEntity: mpPlayer,
         });
+        this.registerBaseObject(player);
+        return player;
     }
 }

package/dist/client/entities/ragemp/router/RageEntityPoolRouter.d.ts

@@ -0,0 +1,12 @@
+import { type IEntity } from "../../../entities/common";
+import { type IBaseObjectDto } from "../../../../shared/entities/IBaseObject";
+import { type IEntityPoolRouter } from "../../../entities/common/router/IEntityPoolRouter";
+export declare class RageEntityPoolRouter implements IEntityPoolRouter {
+    private static readonly _entityPoolsByType;
+    registerByDto(entity: IBaseObjectDto): IEntity | null;
+    unregisterByDto(entity: IBaseObjectDto): IEntity | null;
+    registerFromMp(mpEntity: EntityMp): IEntity | null;
+    resolveFromMp(mpEntity: EntityMp): IEntity | null;
+    private _withEntityPool;
+    private _getMpEntityByRemoteId;
+}

package/dist/client/entities/ragemp/router/RageEntityPoolRouter.js

@@ -0,0 +1,65 @@
+import { RockMod } from "../../../RockMod";
+import { BaseObjectType } from "../../../../shared/entities/IBaseObject";
+export class RageEntityPoolRouter {
+    registerByDto(entity) {
+        return this._withEntityPool(entity.type, (pool) => {
+            const existingEntity = pool.findByRemoteID(entity.remoteId);
+            if (existingEntity) {
+                return existingEntity;
+            }
+            const mpEntity = this._getMpEntityByRemoteId(entity.type, entity.remoteId);
+            if (!mpEntity) {
+                return null;
+            }
+            return pool.registerById(mpEntity.id);
+        });
+    }
+    unregisterByDto(entity) {
+        return this._withEntityPool(entity.type, (pool) => {
+            const existingEntity = pool.findByRemoteID(entity.remoteId);
+            if (!existingEntity) {
+                return null;
+            }
+            return pool.unregisterById(existingEntity.id);
+        });
+    }
+    registerFromMp(mpEntity) {
+        const entityType = mpEntity.type;
+        return this._withEntityPool(entityType, (pool) => pool.registerById(mpEntity.id));
+    }
+    resolveFromMp(mpEntity) {
+        const entityType = mpEntity.type;
+        return this._withEntityPool(entityType, (pool) => pool.findByID(mpEntity.id));
+    }
+    _withEntityPool(entityType, operation) {
+        const rockMod = RockMod.instance;
+        if (!rockMod) {
+            return null;
+        }
+        const resolvePool = RageEntityPoolRouter._entityPoolsByType[entityType];
+        if (!resolvePool) {
+            return null;
+        }
+        return operation(resolvePool(rockMod));
+    }
+    _getMpEntityByRemoteId(entityType, remoteId) {
+        switch (entityType) {
+            case BaseObjectType.Player:
+                return mp.players.atRemoteId(remoteId);
+            case BaseObjectType.Vehicle:
+                return mp.vehicles.atRemoteId(remoteId);
+            case BaseObjectType.Object:
+                return mp.objects.atRemoteId(remoteId);
+            case BaseObjectType.Ped:
+                return mp.peds.atRemoteId(remoteId);
+            default:
+                return null;
+        }
+    }
+}
+RageEntityPoolRouter._entityPoolsByType = {
+    [BaseObjectType.Player]: (rockMod) => rockMod.players,
+    [BaseObjectType.Vehicle]: (rockMod) => rockMod.vehicles,
+    [BaseObjectType.Object]: (rockMod) => rockMod.objects,
+    [BaseObjectType.Ped]: (rockMod) => rockMod.peds,
+};

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

@@ -1,5 +1,6 @@
 import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { type ILightState, type IVehicle } from "../../common/vehicle/IVehicle";
+import { type IRGB } from "../../../../shared/index";
 export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
 }
 export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehicle {
@@ -12,4 +13,31 @@ export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehic
     setEngineHealth(value: number): void;
     setNumberPlate(value: string): void;
     explode(): void;
+    getPedInSeat(seat: number): number;
+    get gear(): number;
+    get speed(): number;
+    get isEngineRunning(): boolean;
+    get lightsState(): ILightState;
+    setUndriveable(toggle: boolean): void;
+    get maxNumberOfPassengers(): number;
+    setEngineOn(toggle: boolean, instantly: boolean, otherwise: boolean): void;
+    get isLocked(): boolean;
+    setIsLocked(value: boolean): void;
+    setCustomPrimaryColour(color: IRGB): void;
+    setCustomSecondaryColour(color: IRGB): void;
+    get customPrimaryColour(): IRGB;
+    get customSecondaryColour(): IRGB;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    getNumMods(modType: number): number;
+    setNeonLightEnabled(index: number, toggle: boolean): void;
+    setNeonLightsColour(color: IRGB): void;
+    setWindowTint(tintType: number): void;
+    get windowTint(): number;
+    setWheelType(wheelType: number): void;
+    get wheelType(): number;
+    setNumberPlateTextIndex(index: number): void;
+    get numberPlateTextIndex(): number;
+    setDoorOpen(doorIndex: number, loose: boolean, openInstantly: boolean): void;
+    setDoorShut(doorIndex: number, instantly: boolean): void;
 }

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

@@ -1,4 +1,5 @@
 import { RageEntity } from "../entity/RageEntity";
+import { RGBA } from "../../../../shared/index";
 export class RageVehicle extends RageEntity {
     get bodyHealth() {
         return this.mpEntity.getBodyHealth();
@@ -27,4 +28,87 @@ export class RageVehicle extends RageEntity {
     explode() {
         return this.mpEntity.explode(true, true);
     }
+    getPedInSeat(seat) {
+        return this.mpEntity.getPedInSeat(seat);
+    }
+    get gear() {
+        return this.mpEntity.gear;
+    }
+    get speed() {
+        return this.mpEntity.getSpeed();
+    }
+    get isEngineRunning() {
+        return this.mpEntity.getIsEngineRunning();
+    }
+    get lightsState() {
+        return this.mpEntity.getLightsState(1, 1);
+    }
+    setUndriveable(toggle) {
+        this.mpEntity.setUndriveable(toggle);
+    }
+    get maxNumberOfPassengers() {
+        return this.mpEntity.getMaxNumberOfPassengers();
+    }
+    setEngineOn(toggle, instantly, otherwise) {
+        this.mpEntity.setEngineOn(toggle, instantly, otherwise);
+    }
+    get isLocked() {
+        return this.mpEntity.locked;
+    }
+    setIsLocked(value) {
+        this.mpEntity.locked = value;
+    }
+    setCustomPrimaryColour(color) {
+        this.mpEntity.setCustomPrimaryColour(color.r, color.g, color.b);
+    }
+    setCustomSecondaryColour(color) {
+        this.mpEntity.setCustomSecondaryColour(color.r, color.g, color.b);
+    }
+    get customPrimaryColour() {
+        const color = this.mpEntity.getCustomPrimaryColour(0, 0, 0);
+        return new RGBA(color.r, color.g, color.b);
+    }
+    get customSecondaryColour() {
+        const color = this.mpEntity.getCustomSecondaryColour(0, 0, 0);
+        return new RGBA(color.r, color.g, color.b);
+    }
+    setMod(modType, modIndex) {
+        this.mpEntity.setMod(modType, modIndex);
+    }
+    getMod(modType) {
+        return this.mpEntity.getMod(modType);
+    }
+    getNumMods(modType) {
+        return this.mpEntity.getNumMods(modType);
+    }
+    setNeonLightEnabled(index, toggle) {
+        this.mpEntity.setNeonLightEnabled(index, toggle);
+    }
+    setNeonLightsColour(color) {
+        this.mpEntity.setNeonLightsColour(color.r, color.g, color.b);
+    }
+    setWindowTint(tintType) {
+        this.mpEntity.setWindowTint(tintType);
+    }
+    get windowTint() {
+        return this.mpEntity.getWindowTint();
+    }
+    setWheelType(wheelType) {
+        this.mpEntity.setWheelType(wheelType);
+    }
+    get wheelType() {
+        return this.mpEntity.getWheelType();
+    }
+    setNumberPlateTextIndex(index) {
+        this.mpEntity.setNumberPlateTextIndex(index);
+    }
+    get numberPlateTextIndex() {
+        return this.mpEntity.getNumberPlateTextIndex();
+    }
+    setDoorOpen(doorIndex, loose, openInstantly) {
+        this.mpEntity.setDoorOpen(doorIndex, loose, openInstantly);
+    }
+    setDoorShut(doorIndex, instantly) {
+        this.mpEntity.setDoorShut(doorIndex, instantly);
+    }
 }

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

@@ -6,4 +6,7 @@ export interface IRageVehicleCreateOptions extends IVehicleCreateOptions {
 export declare class RageVehiclesManager extends RageEntitiesManager<RageVehicle> implements IVehiclesManager {
     constructor();
     create(options: IRageVehicleCreateOptions): RageVehicle;
+    syncWithMpPool(): void;
+    registerById(id: number): RageVehicle;
+    getDisplayNameFromVehicleModel(modelHash: number): string;
 }

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

@@ -20,4 +20,25 @@ export class RageVehiclesManager extends RageEntitiesManager {
         this.registerBaseObject(vehicle);
         return vehicle;
     }
+    syncWithMpPool() {
+        for (const mpVehicle of mp.vehicles.toArray()) {
+            this.registerById(mpVehicle.id);
+        }
+    }
+    registerById(id) {
+        const existingVehicle = this.findByID(id);
+        if (existingVehicle) {
+            return existingVehicle;
+        }
+        const mpVehicle = mp.vehicles.at(id);
+        mpVehicle.isExists = () => mp.vehicles.exists(mpVehicle);
+        const vehicle = new RageVehicle({
+            mpEntity: mpVehicle,
+        });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
+    getDisplayNameFromVehicleModel(modelHash) {
+        return mp.game.vehicle.getDisplayNameFromVehicleModel(modelHash);
+    }
 }

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

@@ -9,4 +9,5 @@ export declare abstract class RageWorldObject<T extends EntityMp> extends RageBa
     protected constructor(options: IRageWorldObjectOptions<T>);
     setPosition(value: Vector3D): void;
     setDimension(value: number): void;
+    setCoords(xPos: number, yPos: number, zPos: number, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void;
 }

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

@@ -17,4 +17,7 @@ export class RageWorldObject extends RageBaseObject {
     setDimension(value) {
         this.mpEntity.dimension = value;
     }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this.mpEntity.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+    }
 }

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

@@ -1,6 +1,8 @@
 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 IBlipsManager, type ICameraManager, type IColshapesManager, type IMarkersManager, type IObjectsManager, type IPedsManager, type IPlayersManager, type IVehiclesManager } from "../../entities";
 import { type IUtilsManager } from "../../utils";
+import { type IBrowserManager, type IChatManager, type IControlsManager, type ICursorManager, type IGameCameraManager, type IGameplayManager, type IRaycastingManager, type IGraphicsManager, type IGuiManager, type IKeysManager, type ILocalPlayerManager, type INametagsManager, type INativeCallerManager, type IGameObjectManager, type IPathfindManager, type IStorageManager, type IStreamingManager, type IUiManager, type IVoiceChatManager, type IWeaponManager, type IZoneManager } from "../../game";
+import { type IConsoleManager } from "../../console";
 export interface IManagersFactory {
     createNetManager(): INetManager;
     createBlipsManager(): IBlipsManager;
@@ -8,7 +10,30 @@ export interface IManagersFactory {
     createMarkersManager(): IMarkersManager;
     createObjectsManager(): IObjectsManager;
     createPedsManager(): IPedsManager;
-    createPlayersManager(net: INetManager): IPlayersManager;
+    createPlayersManager(): IPlayersManager;
     createUtilsManager(): IUtilsManager;
     createVehiclesManager(): IVehiclesManager;
+    createBrowserManager(): IBrowserManager;
+    createChatManager(): IChatManager;
+    createCursorManager(): ICursorManager;
+    createGuiManager(): IGuiManager;
+    createRaycastingManager(): IRaycastingManager;
+    createVoiceChatManager(): IVoiceChatManager;
+    createCameraManager(): ICameraManager;
+    createStorageManager(): IStorageManager;
+    createGraphicsManager(): IGraphicsManager;
+    createNativeManager(): INativeCallerManager;
+    createStreamingManager(): IStreamingManager;
+    createLocalPlayerManager(): ILocalPlayerManager;
+    createControlsManager(): IControlsManager;
+    createKeysManager(): IKeysManager;
+    createGameplayManager(): IGameplayManager;
+    createGameCameraManager(): IGameCameraManager;
+    createUiManager(): IUiManager;
+    createNametagsManager(): INametagsManager;
+    createPathfindManager(): IPathfindManager;
+    createZoneManager(): IZoneManager;
+    createWeaponManager(): IWeaponManager;
+    createGameObjectManager(): IGameObjectManager;
+    createConsoleManager(): IConsoleManager;
 }

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

@@ -1,13 +1,36 @@
 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";
+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 { RageVehiclesManager } from "../../entities/ragemp/vehicle/RageVehiclesManager";
+import { RageNetManager } from "../../net/ragemp/RageNetManager";
+import { RageUtilsManager } from "../../utils/ragemp/RageUtilsManager";
+import { RageBrowserManager } from "../../game/ragemp/browser/RageBrowserManager";
+import { RageChatManager } from "../../game/ragemp/chat/RageChatManager";
+import { RageCameraManager } from "../../entities/ragemp/camera/RageCameraManager";
+import { RageCursorManager } from "../../game/ragemp/cursor/RageCursorManager";
+import { RageStorageManager } from "../../game/ragemp/storage/RageStorageManager";
+import { RageGraphicsManager } from "../../game/ragemp/graphics/RageGraphicsManager";
+import { RageGuiManager } from "../../game/ragemp/gui/RageGuiManager";
+import { RageRaycastingManager } from "../../game/ragemp/raycasting/RageRaycastingManager";
+import { RageNativeCallerManager } from "../../game/ragemp/native/RageNativeCallerManager";
+import { RageStreamingManager } from "../../game/ragemp/streaming/RageStreamingManager";
+import { RageVoiceChatManager } from "../../game/ragemp/voiceChat/RageVoiceChatManager";
+import { RageLocalPlayerManager } from "../../game/ragemp/localPlayer/RageLocalPlayerManager";
+import { RageControlsManager } from "../../game/ragemp/controls/RageControlsManager";
+import { RageKeysManager } from "../../game/ragemp/keys/RageKeysManager";
+import { RageGameplayManager } from "../../game/ragemp/gameplay/RageGameplayManager";
+import { RageGameCameraManager } from "../../game/ragemp/camera/RageGameCameraManager";
+import { RageUiManager } from "../../game/ragemp/ui/RageUiManager";
+import { RageNametagsManager } from "../../game/ragemp/nametags/RageNametagsManager";
+import { RagePathfindManager } from "../../game/ragemp/pathfind/RagePathfindManager";
+import { RageZoneManager } from "../../game/ragemp/zone/RageZoneManager";
+import { RageWeaponManager } from "../../game/ragemp/weapon/RageWeaponManager";
+import { RageGameObjectManager } from "../../game/ragemp/object/RageGameObjectManager";
+import { RageConsoleManager } from "../../console/ragemp/RageConsoleManager";
 export declare class RageManagersFactory implements IManagersFactory {
     createNetManager(): RageNetManager;
     createBlipsManager(): RageBlipsManager;
@@ -15,7 +38,30 @@ export declare class RageManagersFactory implements IManagersFactory {
     createMarkersManager(): RageMarkersManager;
     createObjectsManager(): RageObjectsManager;
     createPedsManager(): RagePedsManager;
-    createPlayersManager(net: RageNetManager): RagePlayersManager;
+    createPlayersManager(): RagePlayersManager;
     createUtilsManager(): RageUtilsManager;
     createVehiclesManager(): RageVehiclesManager;
+    createBrowserManager(): RageBrowserManager;
+    createChatManager(): RageChatManager;
+    createCursorManager(): RageCursorManager;
+    createGuiManager(): RageGuiManager;
+    createRaycastingManager(): RageRaycastingManager;
+    createVoiceChatManager(): RageVoiceChatManager;
+    createCameraManager(): RageCameraManager;
+    createStorageManager(): RageStorageManager;
+    createGraphicsManager(): RageGraphicsManager;
+    createNativeManager(): RageNativeCallerManager;
+    createStreamingManager(): RageStreamingManager;
+    createLocalPlayerManager(): RageLocalPlayerManager;
+    createControlsManager(): RageControlsManager;
+    createKeysManager(): RageKeysManager;
+    createGameplayManager(): RageGameplayManager;
+    createGameCameraManager(): RageGameCameraManager;
+    createUiManager(): RageUiManager;
+    createNametagsManager(): RageNametagsManager;
+    createPathfindManager(): RagePathfindManager;
+    createZoneManager(): RageZoneManager;
+    createWeaponManager(): RageWeaponManager;
+    createGameObjectManager(): RageGameObjectManager;
+    createConsoleManager(): RageConsoleManager;
 }