rock-mod 0.8.3 → 0.9.1

package/dist/client/entities/common/worldObject/IWorldObject.d.ts

@@ -0,0 +1,10 @@
+import { type IBaseObject, type IBaseObjectOptions } from "../baseObject";
+import { type IVector3D } from "@shared/common/utils";
+export interface IWorldObjectOptions extends IBaseObjectOptions {
+}
+export interface IWorldObject extends IBaseObject {
+    get position(): IVector3D;
+    get dimension(): number;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+}

package/dist/client/entities/common/worldObject/IWorldObject.js

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

package/dist/client/entities/common/worldObject/IWorldObjectsIterator.d.ts

@@ -0,0 +1,8 @@
+import { type IBaseObjectsIterator } from "../baseObject/IBaseObjectsIterator";
+import { type IWorldObject } from "./IWorldObject";
+import { type Vector2D, type Vector3D } from "@shared/common/utils";
+export interface IWorldObjectsIterator<T extends IWorldObject> extends IBaseObjectsIterator<T> {
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/client/entities/common/worldObject/IWorldObjectsIterator.js

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

package/dist/client/entities/common/worldObject/IWorldObjectsManager.d.ts

@@ -0,0 +1,13 @@
+import { type IBaseObjectCreateOptions, type IBaseObjectsManager, type IBaseObjectsManagerOptions } from "../baseObject";
+import { type IWorldObject } from "./IWorldObject";
+import { type IWorldObjectsIterator } from "./IWorldObjectsIterator";
+import { type IVector3D } from "@shared/common/utils";
+export interface IWorldObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export interface IWorldObjectCreateOptions extends IBaseObjectCreateOptions {
+    position: IVector3D;
+    dimension: number;
+}
+export interface IWorldObjectsManager<T extends IWorldObject> extends IBaseObjectsManager<T> {
+    get iterator(): IWorldObjectsIterator<T>;
+}

package/dist/client/entities/common/worldObject/IWorldObjectsManager.js

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

package/dist/client/entities/common/worldObject/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IWorldObject";
+export * from "./IWorldObjectsIterator";
+export * from "./IWorldObjectsManager";

package/dist/client/entities/common/worldObject/index.js

@@ -0,0 +1,3 @@
+export * from "./IWorldObject";
+export * from "./IWorldObjectsIterator";
+export * from "./IWorldObjectsManager";

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

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

package/dist/client/entities/index.js

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

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

@@ -0,0 +1,13 @@
+import { type BaseObjectType } from "@shared/entities";
+import { type IBaseObject, type IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+export interface IRageBaseObjectOptions<T extends EntityMp> extends IBaseObjectOptions {
+    mpEntity: T;
+}
+export declare abstract class RageBaseObject<T extends EntityMp = EntityMp> implements IBaseObject {
+    private readonly _mpEntity;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    protected get mpEntity(): T;
+    protected constructor(options: IRageBaseObjectOptions<T>);
+}

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

@@ -0,0 +1,17 @@
+export class RageBaseObject {
+    get id() {
+        return this._mpEntity.id;
+    }
+    get type() {
+        return this._mpEntity.type;
+    }
+    get isExists() {
+        return this._mpEntity.isExists();
+    }
+    get mpEntity() {
+        return this._mpEntity;
+    }
+    constructor(options) {
+        this._mpEntity = options.mpEntity;
+    }
+}

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

@@ -0,0 +1,7 @@
+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>);
+    all(): IterableIterator<T>;
+}

package/dist/client/entities/ragemp/baseObject/RageBaseObjectsIterator.js

@@ -0,0 +1,8 @@
+export class RageBaseObjectsIterator {
+    constructor(baseObjects) {
+        this._baseObjects = baseObjects;
+    }
+    all() {
+        return this._baseObjects.values();
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type IBaseObjectsManager, type IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { type RageBaseObject } from "./RageBaseObject";
+import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
+export interface IRageBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class RageBaseObjectsManager<T extends RageBaseObject<EntityMp>> implements IBaseObjectsManager<RageBaseObject<EntityMp>> {
+    private readonly _baseObjects;
+    private readonly _baseObjectsType;
+    protected readonly _iterator: RageBaseObjectsIterator<T>;
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    get iterator(): RageBaseObjectsIterator<T>;
+    protected constructor(options: IRageBaseObjectsManagerOptions);
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
+}

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

@@ -0,0 +1,46 @@
+import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
+import { RockMod } from "../../../RockMod";
+import { ClientInternalEventName } from "@RockMod/client/net/common/events/types";
+export class RageBaseObjectsManager {
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        this._baseObjects = new Map();
+        this._baseObjectsType = options.baseObjectsType;
+        this._iterator = new RageBaseObjectsIterator(this._baseObjects);
+        mp.events.add("entityDestroyed", (mpEntity) => {
+            if (mpEntity.type === this._baseObjectsType) {
+                const baseObject = this.getByID(mpEntity.id);
+                this.unregisterBaseObject(baseObject);
+            }
+        });
+    }
+    getByID(id) {
+        const baseObject = this.findByID(id);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${id} not found`);
+        }
+        return baseObject;
+    }
+    findByID(id) {
+        const baseObject = this._baseObjects.get(id);
+        return baseObject !== null && baseObject !== void 0 ? baseObject : null;
+    }
+    registerBaseObject(baseObject) {
+        if (this._baseObjects.has(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
+        }
+        this._baseObjects.set(baseObject.id, baseObject);
+        RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityCreated, baseObject);
+    }
+    unregisterBaseObject(baseObject) {
+        if (!this._baseObjects.delete(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
+        }
+        RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityDestroyed, baseObject);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { type IBlip } from "../../common/blip/IBlip";
+import { type IBlipColor, type IBlipSprite } from "@shared/entities";
+export interface IRageBlipOptions extends IRageWorldObjectOptions<EntityMp> {
+}
+export declare class RageBlip extends RageWorldObject<EntityMp> implements IBlip {
+    get sprite(): IBlipSprite;
+    get color(): IBlipColor;
+    get alpha(): number;
+    get shortRange(): boolean;
+    constructor(options: IRageBlipOptions);
+    setSprite(value: IBlipSprite): void;
+    setColor(value: IBlipColor): void;
+    setAlpha(value: number): void;
+}

package/dist/client/entities/ragemp/blip/RageBlip.js

@@ -0,0 +1,27 @@
+import { RageWorldObject } from "../worldObject/RageWorldObject";
+export class RageBlip extends RageWorldObject {
+    get sprite() {
+        return this.mpEntity.getSprite();
+    }
+    get color() {
+        return this.mpEntity.getColour();
+    }
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    get shortRange() {
+        return this.mpEntity.isShortRange();
+    }
+    constructor(options) {
+        super(options);
+    }
+    setSprite(value) {
+        this.mpEntity.setSprite(value);
+    }
+    setColor(value) {
+        this.mpEntity.setColour(value);
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type IBlipCreateOptions, type IBlipsManager } from "../../common";
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { RageBlip } from "./RageBlip";
+export interface IRageBlipCreateOptions extends IBlipCreateOptions {
+}
+export declare class RageBlipsManager extends RageWorldObjectsManager<RageBlip> implements IBlipsManager {
+    constructor();
+    create(options: IRageBlipCreateOptions): RageBlip;
+}

package/dist/client/entities/ragemp/blip/RageBlipsManager.js

@@ -0,0 +1,19 @@
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { RageBlip } from "./RageBlip";
+export class RageBlipsManager extends RageWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "blip",
+        });
+    }
+    create(options) {
+        const { sprite, position } = options;
+        const mpEntity = mp.blips.new(sprite, new mp.Vector3(position), options);
+        mpEntity.isExists = () => mp.blips.exists(mpEntity);
+        const blip = new RageBlip({
+            mpEntity: mpEntity,
+        });
+        this.registerBaseObject(blip);
+        return blip;
+    }
+}

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

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

package/dist/client/entities/ragemp/colshape/RageCircleColshape.js

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

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

@@ -0,0 +1,6 @@
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+export interface IRageColshapeOptions extends IRageWorldObjectOptions<ColshapeMp> {
+}
+export declare abstract class RageColshape extends RageWorldObject<ColshapeMp> {
+    protected constructor(options: IRageColshapeOptions);
+}

package/dist/client/entities/ragemp/colshape/RageColshape.js

@@ -0,0 +1,6 @@
+import { RageWorldObject } from "../worldObject/RageWorldObject";
+export class RageColshape extends RageWorldObject {
+    constructor(options) {
+        super(options);
+    }
+}

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

@@ -0,0 +1,26 @@
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+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";
+import { RageRectangleColshape } from "./RageRectangleColshape";
+import { RageSphereColshape } from "./RageSphereColshape";
+export interface IRageCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
+}
+export interface IRageCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
+}
+export interface IRageCylinderColshapeCreateOptions extends ICylinderColshapeCreateOptions {
+}
+export interface IRageRectangleColshapeCreateOptions extends IRectangleColshapeCreateOptions {
+}
+export interface IRageSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
+}
+export declare class RageColshapesManager extends RageWorldObjectsManager<RageColshape> implements IColshapesManager {
+    constructor();
+    createCircle(options: IRageCircleColshapeCreateOptions): RageCircleColshape;
+    createCuboid(options: IRageCuboidColshapeCreateOptions): RageCuboidColshape;
+    createCylinder(options: IRageCylinderColshapeCreateOptions): RageCylinderColshape;
+    createRectangle(options: IRageRectangleColshapeCreateOptions): RageRectangleColshape;
+    createSphere(options: IRageSphereColshapeCreateOptions): RageSphereColshape;
+}

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

@@ -0,0 +1,58 @@
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { RageCircleColshape } from "./RageCircleColshape";
+import { RageCuboidColshape } from "./RageCuboidColshape";
+import { RageCylinderColshape } from "./RageCylinderColshape";
+import { RageRectangleColshape } from "./RageRectangleColshape";
+import { RageSphereColshape } from "./RageSphereColshape";
+export class RageColshapesManager extends 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({ 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({ 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({ 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({ 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({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+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> {
+    protected constructor(options: IRageEntitiesManagerOptions);
+}

package/dist/client/entities/ragemp/entity/RageEntitiesManager.js

@@ -0,0 +1,6 @@
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+export class RageEntitiesManager extends RageWorldObjectsManager {
+    constructor(options) {
+        super(options);
+    }
+}

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

@@ -0,0 +1,12 @@
+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 {
+    get model(): number;
+    get rotation(): Vector3D;
+    protected constructor(options: IRageEntityOptions<T>);
+    setModel(value: string): void;
+    setRotation(value: Vector3D): void;
+}

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

@@ -0,0 +1,20 @@
+import { RageWorldObject } from "../worldObject/RageWorldObject";
+import { Vector3D } from "../../../../shared/common/utils";
+export class RageEntity extends RageWorldObject {
+    get model() {
+        return this.mpEntity.model;
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rotation;
+        return new Vector3D(x, y, z);
+    }
+    constructor(options) {
+        super(options);
+    }
+    setModel(value) {
+        this.mpEntity.model = mp.game.joaat(value);
+    }
+    setRotation(value) {
+        this.mpEntity.rotation = new mp.Vector3(value);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { type IMarker } from "../../common";
+import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { type IVector3D } from "../../../../shared/common/utils";
+import { type IMarkerType } from "@shared/entities";
+export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
+}
+export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {
+    get markerType(): IMarkerType;
+    get visible(): boolean;
+    get rotation(): IVector3D;
+    constructor(options: IRageMarkerOptions);
+    setVisible(value: boolean): void;
+    setRotation(value: IVector3D): void;
+}

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

@@ -0,0 +1,23 @@
+import { RageWorldObject } from "../worldObject/RageWorldObject";
+import { Vector3D } from "../../../../shared/common/utils";
+export class RageMarker extends RageWorldObject {
+    get markerType() {
+        return this.mpEntity.model;
+    }
+    get visible() {
+        return this.mpEntity.visible;
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rotation;
+        return new Vector3D(x, y, z);
+    }
+    constructor(options) {
+        super(options);
+    }
+    setVisible(value) {
+        this.mpEntity.visible = value;
+    }
+    setRotation(value) {
+        this.mpEntity.rotation = new mp.Vector3(value);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type IMarkerCreateOptions, type 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/client/entities/ragemp/marker/RageMarkersManager.js

@@ -0,0 +1,21 @@
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+import { RageMarker } from "./RageMarker";
+export class RageMarkersManager extends 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.markers.exists(mpEntity);
+        const marker = new RageMarker({ mpEntity });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}

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

@@ -0,0 +1,9 @@
+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 {
+    get alpha(): number;
+    constructor(options: IRageObjectOptions);
+    setAlpha(value: number): void;
+}

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

@@ -0,0 +1,12 @@
+import { RageEntity } from "../entity/RageEntity";
+export class RageObject extends RageEntity {
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type IObjectCreateOptions, type 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/client/entities/ragemp/object/RageObjectsManager.js

@@ -0,0 +1,21 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RageObject } from "./RageObject";
+export class RageObjectsManager extends 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({ mpEntity });
+        this.registerBaseObject(object);
+        return object;
+    }
+}

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

@@ -0,0 +1,7 @@
+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 {
+    constructor(options: IRagePedOptions);
+}