rock-mod 0.1.0 → 0.3.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 is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.
+# Rock-Mod
+
+**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,5 @@
 import { INetManager } from "./net/common/INetManager";
-import { IPlayersManager } from "./entities/common/player/IPlayersManager";
-import { IVehiclesManager } from "./entities/common/vehicle/IVehiclesManager";
+import { IBlipsManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
 type MultiplayerType = "RageMP" | "AltV";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
@@ -10,14 +9,18 @@ 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 _objects;
+    private readonly _peds;
+    private readonly _players;
+    private readonly _vehicles;
     get net(): INetManager;
+    get blips(): IBlipsManager;
+    get objects(): IObjectsManager;
+    get peds(): IPedsManager;
     get players(): IPlayersManager;
     get vehicles(): IVehiclesManager;
     private constructor();
-    init(): void;
 }
 export {};

package/dist/server/RockMod.js

@@ -53,13 +53,24 @@ class RockMod {
             }
         }
     }
-    _managersFactory;
     _net;
+    _blips;
+    _objects;
+    _peds;
     _players;
     _vehicles;
     get net() {
         return this._net;
     }
+    get blips() {
+        return this._blips;
+    }
+    get objects() {
+        return this._objects;
+    }
+    get peds() {
+        return this._peds;
+    }
     get players() {
         return this._players;
     }
@@ -67,13 +78,12 @@ class RockMod {
         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._objects = managersFactory.createObjectsManager();
+        this._peds = managersFactory.createPedsManager();
+        this._players = managersFactory.createPlayersManager();
+        this._vehicles = managersFactory.createVehiclesManager();
     }
 }
 exports.RockMod = RockMod;

package/dist/server/common/utils/color/RGBA.d.ts

@@ -0,0 +1,17 @@
+export interface IRGBA {
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get a(): number | undefined;
+}
+export declare class RGBA implements IRGBA {
+    private readonly _r;
+    private readonly _g;
+    private readonly _b;
+    private readonly _a;
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get a(): number | undefined;
+    constructor(r: number, g: number, b: number, a?: number | undefined);
+}

package/dist/server/common/utils/color/RGBA.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGBA = void 0;
+class RGBA {
+    _r;
+    _g;
+    _b;
+    _a;
+    get r() {
+        return this._r;
+    }
+    get g() {
+        return this._g;
+    }
+    get b() {
+        return this._b;
+    }
+    get a() {
+        return this._a;
+    }
+    constructor(r, g, b, a) {
+        this._r = r;
+        this._g = g;
+        this._b = b;
+        this._a = a;
+    }
+}
+exports.RGBA = RGBA;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RGBA"), exports);

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

@@ -1 +1,2 @@
+export * from "./color";
 export * from "./math";

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

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./color"), exports);
 __exportStar(require("./math"), exports);

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

@@ -7,6 +7,7 @@ export declare abstract class AltVBaseObject<T extends BaseObject> implements IB
     private readonly _mpEntity;
     get id(): number;
     get type(): BaseObjectType;
+    get isExists(): boolean;
     protected get mpEntity(): T;
     protected constructor(options: IAltVBaseObjectOptions<T>);
     destroy(): void;

package/dist/server/entities/altv/baseObject/AltVBaseObject.js

@@ -19,6 +19,9 @@ class AltVBaseObject {
         }
         throw new Error(`BaseObject type ${this._mpEntity.type} not supported`);
     }
+    get isExists() {
+        return this.mpEntity.valid;
+    }
     get mpEntity() {
         return this._mpEntity;
     }

package/dist/server/entities/altv/baseObject/AltVBaseObjectsManager.js

@@ -34,13 +34,13 @@ class AltVBaseObjectsManager {
             throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
         }
         this._baseObjects.set(baseObject.id, baseObject);
-        RockMod_1.RockMod.instance.net.events.emit("entityCreated", baseObject);
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityCreated", baseObject);
     }
     unregisterBaseObject(baseObject) {
         if (!this._baseObjects.delete(baseObject.id)) {
             throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
         }
-        RockMod_1.RockMod.instance.net.events.emit("entityDestroyed", baseObject);
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityCreated", baseObject);
     }
 }
 exports.AltVBaseObjectsManager = AltVBaseObjectsManager;

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/entity/AltVEntity.d.ts

@@ -1,10 +1,13 @@
 import { IEntity } from "../../common/entity/IEntity";
 import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
 import Entity = AltVServer.Entity;
+import { Vector3D } from "../../../common/utils";
 export interface IAltVEntityOptions<T extends Entity> extends IAltVWorldObjectOptions<T> {
 }
 export declare abstract class AltVEntity<T extends Entity> extends AltVWorldObject<T> implements IEntity {
     get model(): number;
+    get rotation(): Vector3D;
     protected constructor(options: IAltVEntityOptions<T>);
     setModel(value: string): void;
+    setRotation(value: Vector3D): void;
 }

package/dist/server/entities/altv/entity/AltVEntity.js

@@ -3,15 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVEntity = void 0;
 const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
 var hash = AltVShared.hash;
+const utils_1 = require("../../../common/utils");
+var Vector3 = AltVShared.Vector3;
 class AltVEntity extends AltVWorldObject_1.AltVWorldObject {
     get model() {
         return this.mpEntity.model;
     }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rot;
+        return new utils_1.Vector3D(x, y, z);
+    }
     constructor(options) {
         super(options);
     }
     setModel(value) {
         this.mpEntity.model = hash(value);
     }
+    setRotation(value) {
+        this.mpEntity.rot = new Vector3(value);
+    }
 }
 exports.AltVEntity = AltVEntity;

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;
+}

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

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

package/dist/server/entities/altv/player/AltVPlayer.d.ts

@@ -1,14 +1,13 @@
 import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
 import { ICustomization, IPlayer } from "../../common/player/IPlayer";
-import { AltVPlayerNetManager } from "./AltVPlayerNetManager";
 import { AltVVehicle } from "../vehicle/AltVVehicle";
 import Player = AltVServer.Player;
 import { Vector3D } from "../../../common/utils/math/Vectors";
+import { IAltVClientEvents } from "../../../net/altv/events/AltVEventsManager";
+import { IAltVClientRPC } from "../../../net/altv/rpc/AltVRPCManager";
 interface AltVPlayerOptions extends IAltVEntityOptions<Player> {
 }
 export declare class AltVPlayer extends AltVEntity<Player> implements IPlayer {
-    private readonly _net;
-    get net(): AltVPlayerNetManager;
     get name(): string;
     get socialClub(): string;
     get heading(): number;
@@ -22,8 +21,9 @@ export declare class AltVPlayer extends AltVEntity<Player> implements IPlayer {
     get weaponAmmo(): number;
     get eyeColor(): number;
     get streamedPlayers(): AltVPlayer[];
-    get isExists(): boolean;
     constructor(options: AltVPlayerOptions);
+    emitEvent<K extends keyof IAltVClientEvents>(eventName: K, ...args: Parameters<IAltVClientEvents[K]>): void;
+    emitRPC<K extends keyof IAltVClientRPC>(rpcName: K, ...args: Parameters<IAltVClientRPC[K]>): Promise<ReturnType<IAltVClientRPC[K]>>;
     spawn(position: Vector3D): void;
     setName(name: string): void;
     setHeading(value: number): void;

package/dist/server/entities/altv/player/AltVPlayer.js

@@ -2,17 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVPlayer = void 0;
 const AltVEntity_1 = require("../entity/AltVEntity");
-const AltVPlayerNetManager_1 = require("./AltVPlayerNetManager");
 const RockMod_1 = require("../../../RockMod");
 var Player = AltVServer.Player;
 var Vehicle = AltVServer.Vehicle;
 var Vector3 = AltVShared.Vector3;
 var hash = AltVShared.hash;
 class AltVPlayer extends AltVEntity_1.AltVEntity {
-    _net;
-    get net() {
-        return this._net;
-    }
     get name() {
         return this.mpEntity.name;
     }
@@ -62,12 +57,14 @@ class AltVPlayer extends AltVEntity_1.AltVEntity {
         }
         return players;
     }
-    get isExists() {
-        return this.mpEntity.valid;
-    }
     constructor(options) {
         super(options);
-        this._net = new AltVPlayerNetManager_1.AltVPlayerNetManager(this.mpEntity);
+    }
+    emitEvent(eventName, ...args) {
+        return RockMod_1.RockMod.instance.net.events.emitClient(this, eventName, ...args);
+    }
+    emitRPC(rpcName, ...args) {
+        return RockMod_1.RockMod.instance.net.rpc.emitClient(this, rpcName, ...args);
     }
     spawn(position) {
         return this.mpEntity.spawn(position);

package/dist/server/entities/altv/vehicle/AltVVehicle.d.ts

@@ -1,10 +1,31 @@
 import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
 import { IVehicle } from "../../common/vehicle/IVehicle";
 import Vehicle = AltVServer.Vehicle;
+import { RGBA } from "../../../common/utils";
+import { AltVPlayer } from "../player/AltVPlayer";
 export interface IAltVVehicleOptions extends IAltVEntityOptions<Vehicle> {
 }
 export declare class AltVVehicle extends AltVEntity<Vehicle> implements IVehicle {
     get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): RGBA;
+    get customSecondaryColor(): RGBA;
+    get driver(): AltVPlayer | null;
+    get passengers(): Set<AltVPlayer>;
     constructor(options: IAltVVehicleOptions);
     setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
+    setLocked(value: boolean): void;
+    setPrimaryColor(value: number): void;
+    setSecondaryColor(value: number): void;
+    setCustomPrimaryColor(value: RGBA): void;
+    setCustomSecondaryColor(value: RGBA): void;
+    explode(): void;
+    repair(): void;
 }