rock-mod 0.0.1 → 0.2.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/dist/index.d.ts

@@ -1 +1 @@
-export * from "./server/RockMod";
+export * from "./server";

package/dist/index.js

@@ -14,4 +14,4 @@ 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("./server/RockMod"), exports);
+__exportStar(require("./server"), exports);

package/dist/server/RockMod.d.ts

@@ -1,3 +1,4 @@
+import { INetManager } from "./net/common/INetManager";
 import { IPlayersManager } from "./entities/common/player/IPlayersManager";
 import { IVehiclesManager } from "./entities/common/vehicle/IVehiclesManager";
 type MultiplayerType = "RageMP" | "AltV";
@@ -5,13 +6,18 @@ export interface RockModOptions {
     multiplayer: MultiplayerType;
 }
 export declare class RockMod {
-    private readonly _options;
-    private readonly _players;
-    private readonly _vehicles;
+    private static _instance?;
+    static create(options: RockModOptions): Promise<RockMod>;
+    static get instance(): RockMod;
+    private static _initManagersFactory;
+    private readonly _managersFactory;
+    private readonly _net;
+    private _players;
+    private _vehicles;
+    get net(): INetManager;
     get players(): IPlayersManager;
     get vehicles(): IVehiclesManager;
-    constructor(options: RockModOptions);
+    private constructor();
     init(): void;
-    private _initManagersFactory;
 }
 export {};

package/dist/server/RockMod.js

@@ -1,37 +1,79 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RockMod = void 0;
-const AltVManagersFactory_1 = require("./entities/altv/AltVManagersFactory");
-const RageManagersFactory_1 = require("./entities/ragemp/RageManagersFactory");
 class RockMod {
-    _options;
+    static _instance;
+    static async create(options) {
+        if (this._instance) {
+            throw new Error("RockMod already created");
+        }
+        const managersFactory = await this._initManagersFactory(options);
+        this._instance = new RockMod(managersFactory);
+        return this._instance;
+    }
+    static get instance() {
+        if (!this._instance) {
+            throw new Error("RockMod not created");
+        }
+        return this._instance;
+    }
+    static async _initManagersFactory(options) {
+        const { multiplayer } = options;
+        switch (multiplayer) {
+            case "AltV": {
+                const { AltVManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/altv/AltVManagersFactory")));
+                return new AltVManagersFactory();
+            }
+            case "RageMP": {
+                const { RageManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/ragemp/RageManagersFactory")));
+                return new RageManagersFactory();
+            }
+        }
+    }
+    _managersFactory;
+    _net;
     _players;
     _vehicles;
+    get net() {
+        return this._net;
+    }
     get players() {
         return this._players;
     }
     get vehicles() {
         return this._vehicles;
     }
-    constructor(options) {
-        this._options = options;
-        const managersFactory = this._initManagersFactory();
-        this._players = managersFactory.createPlayersManager();
-        this._vehicles = managersFactory.createVehiclesManager();
+    constructor(managersFactory) {
+        this._managersFactory = managersFactory;
+        this._net = managersFactory.createNetManager();
     }
     init() {
         console.log("RockMod init");
-    }
-    _initManagersFactory() {
-        const { multiplayer } = this._options;
-        switch (multiplayer) {
-            case "AltV": {
-                return new AltVManagersFactory_1.AltVManagersFactory();
-            }
-            case "RageMP": {
-                return new RageManagersFactory_1.RageManagersFactory();
-            }
-        }
+        this._players = this._managersFactory.createPlayersManager();
+        this._vehicles = this._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

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

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

@@ -0,0 +1,18 @@
+"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("./color"), exports);
+__exportStar(require("./math"), exports);

package/dist/server/common/utils/math/Math.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Math {
+        clamp(value: number, min: number, max: number): number;
+    }
+}
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/server/common/utils/math/Math.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = clamp;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+Math.clamp = clamp;

package/dist/server/common/utils/math/Vectors.d.ts

@@ -1,4 +1,17 @@
-export declare class Vector2D {
+export interface IVector2D {
+    get x(): number;
+    get y(): number;
+    distanceTo(position: IVector2D): number;
+    squaredDistanceTo(position: IVector2D): number;
+    isInRange(position: IVector2D, range: number): boolean;
+}
+export interface IVector3D extends IVector2D {
+    get z(): number;
+    distanceTo(position: IVector3D): number;
+    squaredDistanceTo(position: IVector3D): number;
+    isInRange(position: IVector3D, range: number): boolean;
+}
+export declare class Vector2D implements IVector2D {
     private readonly _x;
     private readonly _y;
     get x(): number;
@@ -8,7 +21,7 @@ export declare class Vector2D {
     squaredDistanceTo(position: Vector2D): number;
     isInRange(position: Vector2D, range: number): boolean;
 }
-export declare class Vector3D extends Vector2D {
+export declare class Vector3D extends Vector2D implements IVector3D {
     private readonly _z;
     get z(): number;
     constructor(x: number, y: number, z: number);

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

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

package/dist/server/common/utils/math/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("./Vectors"), exports);

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

@@ -1,9 +1,14 @@
 import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
-export declare abstract class AltVBaseObject implements IBaseObject {
-    private readonly _id;
-    private readonly _type;
+import BaseObject = AltVServer.BaseObject;
+export interface IAltVBaseObjectOptions<T extends BaseObject> extends IBaseObjectOptions {
+    mpEntity: T;
+}
+export declare abstract class AltVBaseObject<T extends BaseObject> implements IBaseObject {
+    private readonly _mpEntity;
     get id(): number;
     get type(): BaseObjectType;
-    protected constructor(options: IBaseObjectOptions);
+    get isExists(): boolean;
+    protected get mpEntity(): T;
+    protected constructor(options: IAltVBaseObjectOptions<T>);
     destroy(): void;
 }

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVBaseObject = void 0;
+const IBaseObject_1 = require("../../common/baseObject/IBaseObject");
+var BaseObjectTypeMP = AltVShared.BaseObjectType;
 class AltVBaseObject {
-    _id;
-    _type;
+    _mpEntity;
     get id() {
-        return this._id;
+        return this._mpEntity.id;
     }
     get type() {
-        return this._type;
+        switch (this._mpEntity.type) {
+            case BaseObjectTypeMP.Player: {
+                return IBaseObject_1.BaseObjectType.Player;
+            }
+            case BaseObjectTypeMP.Vehicle: {
+                return IBaseObject_1.BaseObjectType.Vehicle;
+            }
+        }
+        throw new Error(`BaseObject type ${this._mpEntity.type} not supported`);
+    }
+    get isExists() {
+        return this.mpEntity.valid;
+    }
+    get mpEntity() {
+        return this._mpEntity;
     }
     constructor(options) {
-        this._id = options.id;
-        this._type = options.type;
+        this._mpEntity = options.mpEntity;
     }
     destroy() {
         console.log("destroy");

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

@@ -1,6 +1,7 @@
 import { AltVBaseObject } from "./AltVBaseObject";
 import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
-export declare class AltVBaseObjectsIterator<T extends AltVBaseObject> implements IBaseObjectsIterator<T> {
+import BaseObject = AltVServer.BaseObject;
+export declare class AltVBaseObjectsIterator<T extends AltVBaseObject<BaseObject>> implements IBaseObjectsIterator<T> {
     private readonly _baseObjects;
     constructor(baseObjects: ReadonlyMap<number, T>);
     all(): IterableIterator<T>;

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

@@ -1,13 +1,18 @@
 import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
 import { AltVBaseObject } from "./AltVBaseObject";
 import { AltVBaseObjectsIterator } from "./AltVBaseObjectsIterator";
-export declare abstract class AltVBaseObjectsManager<T extends AltVBaseObject> implements IBaseObjectsManager<T> {
+import BaseObject = AltVServer.BaseObject;
+export interface IAltVBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class AltVBaseObjectsManager<T extends AltVBaseObject<BaseObject>> implements IBaseObjectsManager<T> {
     private readonly _baseObjects;
     private readonly _baseObjectsType;
     protected readonly _iterator: AltVBaseObjectsIterator<T>;
     protected get baseObjects(): ReadonlyMap<number, T>;
     get iterator(): AltVBaseObjectsIterator<T>;
-    protected constructor(options: IBaseObjectsManagerOptions);
+    protected constructor(options: IAltVBaseObjectsManagerOptions);
     getByID(id: number): T;
     findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVBaseObjectsManager = void 0;
 const AltVBaseObjectsIterator_1 = require("./AltVBaseObjectsIterator");
+const RockMod_1 = require("../../../RockMod");
 class AltVBaseObjectsManager {
     _baseObjects;
     _baseObjectsType;
@@ -28,5 +29,18 @@ class AltVBaseObjectsManager {
         const baseObject = this._baseObjects.get(id);
         return 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_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("rm::entityCreated", baseObject);
+    }
 }
 exports.AltVBaseObjectsManager = AltVBaseObjectsManager;

package/dist/server/entities/altv/entity/AltVEntitiesManager.d.ts

@@ -1,5 +1,6 @@
 import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
 import { AltVEntity } from "./AltVEntity";
 import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
-export declare abstract class AltVEntitiesManager<T extends AltVEntity> extends AltVWorldObjectsManager<T> implements IEntitiesManager<T> {
+import Entity = AltVServer.Entity;
+export declare abstract class AltVEntitiesManager<T extends AltVEntity<Entity>> extends AltVWorldObjectsManager<T> implements IEntitiesManager<T> {
 }

package/dist/server/entities/altv/entity/AltVEntity.d.ts

@@ -1,8 +1,13 @@
-import { IEntity, IEntityOptions } from "../../common/entity/IEntity";
-import { AltVWorldObject } from "../worldObject/AltVWorldObject";
-export declare abstract class AltVEntity extends AltVWorldObject implements IEntity {
-    private _model;
-    get model(): string;
-    protected constructor(options: IEntityOptions);
+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

@@ -2,17 +2,25 @@
 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 {
-    _model;
     get model() {
-        return this._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);
-        this._model = options.model;
     }
     setModel(value) {
-        this._model = value;
+        this.mpEntity.model = hash(value);
+    }
+    setRotation(value) {
+        this.mpEntity.rot = new Vector3(value);
     }
 }
 exports.AltVEntity = AltVEntity;

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

@@ -1,13 +1,47 @@
-import { AltVEntity } from "../entity/AltVEntity";
-import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
-export declare class AltVPlayer extends AltVEntity implements IPlayer {
-    private _name;
-    private readonly _socialClub;
-    private _health;
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import { ICustomization, IPlayer } from "../../common/player/IPlayer";
+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 {
     get name(): string;
     get socialClub(): string;
+    get heading(): number;
     get health(): number;
-    constructor(options: IPlayerOptions);
-    setName(value: string): void;
+    get armour(): number;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): AltVVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): AltVPlayer[];
+    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;
     setHealth(value: number): void;
+    setArmour(value: number): void;
+    setWeaponAmmo(weapon: string, ammo: number): void;
+    giveWeapon(weapon: string, ammo: number): void;
+    removeWeapon(weapon: string): void;
+    enableVoiceTo(player: AltVPlayer): void;
+    disableVoiceTo(player: AltVPlayer): void;
+    putIntoVehicle(vehicle: AltVVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(data: Partial<ICustomization>): void;
+    setHeadOverlay(overlayID: number, index: number, opacity: number, firstColor: number, secondColor: number): void;
+    setEyeColor(colorID: number): void;
+    setProp(propID: number, drawableID: number, textureID: number): void;
+    setClothes(componentID: number, drawableID: number, textureID: number, paletteID: number): void;
+    setHairColor(colorID: number, highlightColorID: number): void;
+    kick(reason?: string): void;
 }
+export {};