rock-mod 0.2.0 → 0.5.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Carter
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Carter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# rock-mod
+# Rock-Mod
 
-Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.
+**Rock-Mod** is a versatile and powerful framework designed for cross-platform mod development for Grand Theft Auto (GTA) servers. It supports both **RageMP** and **AltV** multiplayer platforms, allowing you to build and manage mods seamlessly across these environments.
+
+### Installation
+
+To get started, simply install the package:
+
+```bash
+npm install rock-mod
+```
+
+### Usage
+
+On the server-side, initialize Rock-Mod with the appropriate multiplayer type:
+
+```typescript
+const rockMod = await RockMod.create({
+  multiplayer: "RageMP", // or "AltV"
+});
+```
+
+Please note that client-side implementation is not yet available in this version.
+
+Rock-Mod simplifies multiplayer mod development by providing unified tools for managing game entities, networking, and more across different platforms.

package/dist/server/RockMod.d.ts

@@ -1,6 +1,6 @@
 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";
 type MultiplayerType = "RageMP" | "AltV";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
@@ -10,14 +10,24 @@ export declare class RockMod {
     static create(options: RockModOptions): Promise<RockMod>;
     static get instance(): RockMod;
     private static _initManagersFactory;
-    private readonly _managersFactory;
     private readonly _net;
-    private _players;
-    private _vehicles;
+    private readonly _blips;
+    private readonly _colshapes;
+    private readonly _markers;
+    private readonly _objects;
+    private readonly _peds;
+    private readonly _players;
+    private readonly _utils;
+    private readonly _vehicles;
     get net(): INetManager;
+    get blips(): IBlipsManager;
+    get colshapes(): IColshapesManager;
+    get markers(): IMarkersManager;
+    get objects(): IObjectsManager;
+    get peds(): IPedsManager;
     get players(): IPlayersManager;
+    get utils(): IUtilsManager;
     get vehicles(): IVehiclesManager;
     private constructor();
-    init(): void;
 }
 export {};

package/dist/server/RockMod.js

@@ -53,27 +53,52 @@ class RockMod {
             }
         }
     }
-    _managersFactory;
     _net;
+    _blips;
+    _colshapes;
+    _markers;
+    _objects;
+    _peds;
     _players;
+    _utils;
     _vehicles;
     get net() {
         return this._net;
     }
+    get blips() {
+        return this._blips;
+    }
+    get colshapes() {
+        return this._colshapes;
+    }
+    get markers() {
+        return this._markers;
+    }
+    get objects() {
+        return this._objects;
+    }
+    get peds() {
+        return this._peds;
+    }
     get players() {
         return this._players;
     }
+    get utils() {
+        return this._utils;
+    }
     get vehicles() {
         return this._vehicles;
     }
     constructor(managersFactory) {
-        this._managersFactory = managersFactory;
         this._net = managersFactory.createNetManager();
-    }
-    init() {
-        console.log("RockMod init");
-        this._players = this._managersFactory.createPlayersManager();
-        this._vehicles = this._managersFactory.createVehiclesManager();
+        this._blips = managersFactory.createBlipsManager();
+        this._colshapes = managersFactory.createColshapesManager();
+        this._markers = managersFactory.createMarkersManager();
+        this._objects = managersFactory.createObjectsManager();
+        this._peds = managersFactory.createPedsManager();
+        this._players = managersFactory.createPlayersManager(this._net);
+        this._utils = managersFactory.createUtilsManager();
+        this._vehicles = managersFactory.createVehiclesManager();
     }
 }
 exports.RockMod = RockMod;

package/dist/server/entities/altv/blip/AltVBlip.d.ts

@@ -0,0 +1,15 @@
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+import { IBlip, IBlipColor, IBlipSprite } from "../../common";
+export interface IAltVBlipOptions extends IAltVWorldObjectOptions<AltVServer.Blip> {
+}
+export declare class AltVBlip extends AltVWorldObject<AltVServer.Blip> implements IBlip {
+    get sprite(): IBlipSprite;
+    get alpha(): number;
+    get name(): string;
+    get color(): IBlipColor;
+    constructor(options: IAltVBlipOptions);
+    setSprite(value: IBlipSprite): void;
+    setAlpha(value: number): void;
+    setName(value: string): void;
+    setColor(value: IBlipColor): void;
+}

package/dist/server/entities/altv/blip/AltVBlip.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBlip = void 0;
+const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+class AltVBlip extends AltVWorldObject_1.AltVWorldObject {
+    get sprite() {
+        return this.mpEntity.sprite;
+    }
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    get name() {
+        return this.mpEntity.name;
+    }
+    get color() {
+        return this.mpEntity.color;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setSprite(value) {
+        this.mpEntity.sprite = value;
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+    setName(value) {
+        this.mpEntity.name = value;
+    }
+    setColor(value) {
+        this.mpEntity.color = value;
+    }
+}
+exports.AltVBlip = AltVBlip;

package/dist/server/entities/altv/blip/AltVBlipsManager.d.ts

@@ -0,0 +1,9 @@
+import { IBlipCreateOptions, IBlipsManager } from "../../common";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+import { AltVBlip } from "./AltVBlip";
+export interface IAltVBlipCreateOptions extends IBlipCreateOptions {
+}
+export declare class AltVBlipsManager extends AltVWorldObjectsManager<AltVBlip> implements IBlipsManager {
+    constructor();
+    create(options: IAltVBlipCreateOptions): AltVBlip;
+}

package/dist/server/entities/altv/blip/AltVBlipsManager.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBlipsManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVBlip_1 = require("./AltVBlip");
+var PointBlip = AltVServer.PointBlip;
+var Vector3 = AltVShared.Vector3;
+class AltVBlipsManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "blip",
+        });
+    }
+    create(options) {
+        const { sprite, position, dimension, alpha } = options;
+        const mpEntity = new PointBlip(new Vector3(position), true);
+        mpEntity.sprite = sprite;
+        mpEntity.dimension = dimension;
+        mpEntity.alpha = alpha;
+        const blip = new AltVBlip_1.AltVBlip({ mpEntity });
+        this.registerBaseObject(blip);
+        return blip;
+    }
+}
+exports.AltVBlipsManager = AltVBlipsManager;

package/dist/server/entities/altv/colshape/AltVCircleColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICircleColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCircleColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCircleColshape extends AltVColshape implements ICircleColshape {
+    constructor(options: IAltVCircleColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCircleColshape.js

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

package/dist/server/entities/altv/colshape/AltVColshape.d.ts

@@ -0,0 +1,7 @@
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+import Colshape = AltVServer.Colshape;
+export interface IAltVColshapeOptions extends IAltVWorldObjectOptions<Colshape> {
+}
+export declare abstract class AltVColshape extends AltVWorldObject<Colshape> {
+    protected constructor(options: IAltVColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVColshape.js

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

package/dist/server/entities/altv/colshape/AltVColshapesManager.d.ts

@@ -0,0 +1,26 @@
+import { ICircleColshapeCreateOptions, IColshapesManager, ICuboidColshapeCreateOptions, ICylinderColshapeCreateOptions, IRectangleColshapeCreateOptions, ISphereColshapeCreateOptions } from "../../common";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+import { AltVColshape } from "./AltVColshape";
+import { AltVCircleColshape } from "./AltVCircleColshape";
+import { AltVCuboidColshape } from "./AltVCuboidColshape";
+import { AltVCylinderColshape } from "./AltVCylinderColshape";
+import { AltVRectangleColshape } from "./AltVRectangleColshape";
+import { AltVSphereColshape } from "./AltVSphereColshape";
+export interface IAltVCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
+}
+export interface IAltVCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
+}
+export interface IAltVCylinderColshapeCreateOptions extends ICylinderColshapeCreateOptions {
+}
+export interface IAltVRectangleColshapeCreateOptions extends IRectangleColshapeCreateOptions {
+}
+export interface IAltVSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
+}
+export declare class AltVColshapesManager extends AltVWorldObjectsManager<AltVColshape> implements IColshapesManager {
+    constructor();
+    createCircle(options: IAltVCircleColshapeCreateOptions): AltVCircleColshape;
+    createCuboid(options: IAltVCuboidColshapeCreateOptions): AltVCuboidColshape;
+    createCylinder(options: IAltVCylinderColshapeCreateOptions): AltVCylinderColshape;
+    createRectangle(options: IAltVRectangleColshapeCreateOptions): AltVRectangleColshape;
+    createSphere(options: IAltVSphereColshapeCreateOptions): AltVSphereColshape;
+}

package/dist/server/entities/altv/colshape/AltVColshapesManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVColshapesManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVCircleColshape_1 = require("./AltVCircleColshape");
+const AltVCuboidColshape_1 = require("./AltVCuboidColshape");
+const AltVCylinderColshape_1 = require("./AltVCylinderColshape");
+const AltVRectangleColshape_1 = require("./AltVRectangleColshape");
+const AltVSphereColshape_1 = require("./AltVSphereColshape");
+var ColshapeCircle = AltVServer.ColshapeCircle;
+var ColshapeCuboid = AltVServer.ColshapeCuboid;
+var ColshapeCylinder = AltVServer.ColshapeCylinder;
+var ColshapeRectangle = AltVServer.ColshapeRectangle;
+var ColshapeSphere = AltVServer.ColshapeSphere;
+class AltVColshapesManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "colshape",
+        });
+    }
+    createCircle(options) {
+        const { range, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = new ColshapeCircle(x, y, range);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCircleColshape_1.AltVCircleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { width, depth, height, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeCuboid(x, y, z, x + width, y + depth, z + height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCuboidColshape_1.AltVCuboidColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { height, range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeCylinder(x, y, z, range, height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCylinderColshape_1.AltVCylinderColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(options) {
+        const { width, height, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = new ColshapeRectangle(x, y, x + width, y + height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVRectangleColshape_1.AltVRectangleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createSphere(options) {
+        const { range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeSphere(x, y, z, range);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVSphereColshape_1.AltVSphereColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}
+exports.AltVColshapesManager = AltVColshapesManager;

package/dist/server/entities/altv/colshape/AltVCuboidColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICuboidColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCuboidColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCuboidColshape extends AltVColshape implements ICuboidColshape {
+    constructor(options: IAltVCuboidColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCuboidColshape.js

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

package/dist/server/entities/altv/colshape/AltVCylinderColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICylinderColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCylinderColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCylinderColshape extends AltVColshape implements ICylinderColshape {
+    constructor(options: IAltVCylinderColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCylinderColshape.js

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

package/dist/server/entities/altv/colshape/AltVRectangleColshape.d.ts

@@ -0,0 +1,7 @@
+import { IRectangleColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVRectangleColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVRectangleColshape extends AltVColshape implements IRectangleColshape {
+    constructor(options: IAltVRectangleColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVRectangleColshape.js

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

package/dist/server/entities/altv/colshape/AltVSphereColshape.d.ts

@@ -0,0 +1,7 @@
+import { ISphereColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVSphereColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVSphereColshape extends AltVColshape implements ISphereColshape {
+    constructor(options: IAltVSphereColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVSphereColshape.js

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

package/dist/server/entities/altv/marker/AltVMarker.d.ts

@@ -0,0 +1,12 @@
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+import Marker = AltVServer.Marker;
+import { IMarker } from "../../common";
+export interface IAltVMarkerOptions extends IAltVWorldObjectOptions<Marker> {
+}
+export declare class AltVMarker extends AltVWorldObject<Marker> implements IMarker {
+    get visible(): boolean;
+    get scale(): number;
+    constructor(options: IAltVMarkerOptions);
+    setVisible(value: boolean): void;
+    setScale(value: number): void;
+}

package/dist/server/entities/altv/marker/AltVMarker.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVMarker = void 0;
+const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+var Vector3 = AltVShared.Vector3;
+class AltVMarker extends AltVWorldObject_1.AltVWorldObject {
+    get visible() {
+        return this.mpEntity.visible;
+    }
+    get scale() {
+        return this.mpEntity.scale.z;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setVisible(value) {
+        this.mpEntity.visible = value;
+    }
+    setScale(value) {
+        this.mpEntity.scale = new Vector3(0, 0, value);
+    }
+}
+exports.AltVMarker = AltVMarker;

package/dist/server/entities/altv/marker/AltVMarkersManager.d.ts

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

package/dist/server/entities/altv/marker/AltVMarkersManager.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVMarkersManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVMarker_1 = require("./AltVMarker");
+var alt = AltVServer;
+var Vector3 = AltVShared.Vector3;
+class AltVMarkersManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "marker",
+        });
+    }
+    create(options) {
+        const { type, scale, color, position, dimension, rotation } = options;
+        const mpEntity = new alt.Marker(type, new Vector3(position), color);
+        mpEntity.scale = new Vector3(scale, scale, scale);
+        mpEntity.dimension = dimension;
+        mpEntity.rot = new Vector3(rotation);
+        const marker = new AltVMarker_1.AltVMarker({ mpEntity });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}
+exports.AltVMarkersManager = AltVMarkersManager;

package/dist/server/entities/altv/object/AltVObject.d.ts

@@ -0,0 +1,9 @@
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import { IObject } from "../../common/object/IObject";
+export interface IAltVObjectOptions extends IAltVEntityOptions<AltVServer.Object> {
+}
+export declare class AltVObject extends AltVEntity<AltVServer.Object> implements IObject {
+    get alpha(): number;
+    constructor(options: IAltVObjectOptions);
+    setAlpha(value: number): void;
+}

package/dist/server/entities/altv/object/AltVObject.js

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

package/dist/server/entities/altv/object/AltVObjectsManager.d.ts

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

package/dist/server/entities/altv/object/AltVObjectsManager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVObjectsManager = void 0;
+const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+const AltVObject_1 = require("./AltVObject");
+var alt = AltVServer;
+class AltVObjectsManager extends AltVEntitiesManager_1.AltVEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "object",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation, alpha } = options;
+        const mpEntity = new alt.Object(model, position, rotation, alpha);
+        mpEntity.dimension = dimension;
+        const object = new AltVObject_1.AltVObject({ mpEntity });
+        this.registerBaseObject(object);
+        return object;
+    }
+}
+exports.AltVObjectsManager = AltVObjectsManager;

package/dist/server/entities/altv/ped/AltVPed.d.ts

@@ -0,0 +1,8 @@
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import Ped = AltVServer.Ped;
+import { IPed } from "../../common";
+export interface IAltVPedOptions extends IAltVEntityOptions<Ped> {
+}
+export declare class AltVPed extends AltVEntity<Ped> implements IPed {
+    constructor(options: IAltVPedOptions);
+}

package/dist/server/entities/altv/ped/AltVPed.js

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

package/dist/server/entities/altv/ped/AltVPedsManager.d.ts

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