@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

package/dist/runtime/client/services/textui.service.js

@@ -0,0 +1,127 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+const DEFAULT_OPTIONS = {
+    font: 4,
+    scale: 0.35,
+    color: { r: 255, g: 255, b: 255, a: 255 },
+    alignment: 0,
+    dropShadow: true,
+    outline: false,
+    wrapWidth: 0,
+};
+const DEFAULT_3D_OPTIONS = {
+    ...DEFAULT_OPTIONS,
+    scale: 0.25,
+    background: false,
+    backgroundColor: { r: 0, g: 0, b: 0, a: 150 },
+    backgroundPadding: 0.002,
+};
+let TextUIService = class TextUIService {
+    platform;
+    runtime;
+    activeTextUI = null;
+    tickHandle = null;
+    constructor(platform, runtime) {
+        this.platform = platform;
+        this.runtime = runtime;
+    }
+    show(text, options = {}) {
+        this.activeTextUI = { text, options: { ...DEFAULT_OPTIONS, ...options } };
+        this.ensureTickRunning();
+    }
+    hide() {
+        this.activeTextUI = null;
+        this.stopTick();
+    }
+    isVisible() {
+        return this.activeTextUI !== null;
+    }
+    drawText(text, x, y, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        this.platform.setTextFont(opts.font);
+        this.platform.setTextScale(opts.scale);
+        this.platform.setTextColour(opts.color);
+        this.platform.setTextJustification(opts.alignment);
+        if (opts.dropShadow) {
+            this.platform.setTextDropshadow(0, 0, 0, 0, 255);
+            this.platform.setTextDropShadow();
+        }
+        if (opts.outline)
+            this.platform.setTextOutline();
+        if (opts.wrapWidth > 0)
+            this.platform.setTextWrap(x, x + opts.wrapWidth);
+        if (opts.alignment === 2) {
+            this.platform.setTextRightJustify(true);
+            this.platform.setTextWrap(0.0, x);
+        }
+        this.platform.beginTextCommandDisplayText('STRING');
+        this.platform.addTextComponentString(text);
+        this.platform.endTextCommandDisplayText(x, y);
+    }
+    drawText3D(position, text, options = {}) {
+        const opts = { ...DEFAULT_3D_OPTIONS, ...options };
+        const screen = this.platform.worldToScreen(position);
+        if (!screen.onScreen)
+            return;
+        const distance = this.platform.getDistanceBetweenCoords(this.platform.getGameplayCamCoords(), position, true);
+        const scale = opts.scale * (1 / Math.max(distance, 0.001)) * 2;
+        const scaledScale = Math.max(scale, 0.15);
+        if (opts.background) {
+            const factor = text.length / 300;
+            this.platform.drawRect(screen.x, screen.y + opts.backgroundPadding, factor + opts.backgroundPadding * 2, 0.03 + opts.backgroundPadding * 2, opts.backgroundColor.r, opts.backgroundColor.g, opts.backgroundColor.b, opts.backgroundColor.a);
+        }
+        this.platform.setTextScale(scaledScale);
+        this.platform.setTextFont(opts.font);
+        this.platform.setTextColour(opts.color);
+        this.platform.setTextCentre(true);
+        if (opts.dropShadow) {
+            this.platform.setTextDropshadow(0, 0, 0, 0, 255);
+            this.platform.setTextDropShadow();
+        }
+        if (opts.outline)
+            this.platform.setTextOutline();
+        this.platform.beginTextCommandDisplayText('STRING');
+        this.platform.addTextComponentString(text);
+        this.platform.endTextCommandDisplayText(screen.x, screen.y);
+    }
+    getTextWidth(text, _font, scale) {
+        return text.length * 0.01 * scale;
+    }
+    ensureTickRunning() {
+        if (this.tickHandle !== null)
+            return;
+        this.tickHandle = this.runtime.setTick(() => {
+            if (!this.activeTextUI)
+                return;
+            const { text, options } = this.activeTextUI;
+            this.drawText(text, 0.985, 0.93, { ...options, alignment: 2 });
+        });
+    }
+    stopTick() {
+        if (this.tickHandle !== null) {
+            this.runtime.clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+    }
+};
+TextUIService = __decorate([
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge,
+        IClientRuntimeBridge])
+], TextUIService);
+export { TextUIService };

package/dist/runtime/client/services/vehicle-client.service.d.ts

@@ -0,0 +1,43 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../../server/types/vehicle.types';
+export declare class VehicleClientService {
+    private readonly events;
+    private readonly platform;
+    private readonly runtime;
+    private pendingCreations;
+    private pendingDeletes;
+    private pendingRepairs;
+    private pendingData;
+    private pendingPlayerVehicles;
+    private requestIdCounter;
+    constructor(events: EventsAPI<'client'>, platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    createVehicle(options: Omit<VehicleCreateOptions, 'ownership'>): Promise<VehicleSpawnResult>;
+    deleteVehicle(networkId: number): Promise<boolean>;
+    repairVehicle(networkId: number): Promise<boolean>;
+    getClosestVehicle(radius?: number): number | null;
+    isPlayerInVehicle(): boolean;
+    getCurrentVehicle(): number | null;
+    getLastVehicle(): number | null;
+    isPlayerDriver(): boolean;
+    getSpeed(vehicle: number): number;
+    getNetworkId(vehicle: number): number;
+    getVehicleFromNetworkId(networkId: number): number;
+    getVehicleState<T = any>(vehicle: number, key: string): T | undefined;
+    setDoorsLocked(networkId: number, locked: boolean): void;
+    getVehicleData(networkId: number): Promise<SerializedVehicleData | null>;
+    getPlayerVehicles(): Promise<SerializedVehicleData[]>;
+    warpIntoVehicle(vehicle: number, seatIndex?: number): void;
+    setHeading(vehicle: number, heading: number): void;
+    getPosition(vehicle: number): Vector3 | null;
+    getHeading(vehicle: number): number;
+    getModel(vehicle: number): number;
+    getPlate(vehicle: number): string;
+    applyMods(vehicle: number, mods: Record<string, any>): void;
+    repair(vehicle: number): void;
+    setFuel(vehicle: number, level: number): void;
+    private registerEventHandlers;
+    private waitForVehicle;
+}

package/dist/runtime/client/services/vehicle-client.service.js

@@ -0,0 +1,337 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+let VehicleClientService = class VehicleClientService {
+    events;
+    platform;
+    runtime;
+    pendingCreations = new Map();
+    pendingDeletes = new Map();
+    pendingRepairs = new Map();
+    pendingData = new Map();
+    pendingPlayerVehicles = null;
+    requestIdCounter = 0;
+    constructor(events, platform, runtime) {
+        this.events = events;
+        this.platform = platform;
+        this.runtime = runtime;
+        this.registerEventHandlers();
+    }
+    async createVehicle(options) {
+        return new Promise((resolve) => {
+            const requestId = this.requestIdCounter++;
+            this.pendingCreations.set(requestId, resolve);
+            this.events.emit('opencore:vehicle:create', { ...options, _requestId: requestId });
+            setTimeout(() => {
+                if (!this.pendingCreations.has(requestId))
+                    return;
+                this.pendingCreations.delete(requestId);
+                resolve({ networkId: 0, handle: 0, success: false, error: 'Request timeout' });
+            }, 5000);
+        });
+    }
+    async deleteVehicle(networkId) {
+        return new Promise((resolve) => {
+            this.pendingDeletes.set(networkId, resolve);
+            this.events.emit('opencore:vehicle:delete', networkId);
+            setTimeout(() => {
+                if (!this.pendingDeletes.has(networkId))
+                    return;
+                this.pendingDeletes.delete(networkId);
+                resolve(false);
+            }, 5000);
+        });
+    }
+    async repairVehicle(networkId) {
+        return new Promise((resolve) => {
+            this.pendingRepairs.set(networkId, resolve);
+            this.events.emit('opencore:vehicle:repair', networkId);
+            setTimeout(() => {
+                if (!this.pendingRepairs.has(networkId))
+                    return;
+                this.pendingRepairs.delete(networkId);
+                resolve(false);
+            }, 5000);
+        });
+    }
+    getClosestVehicle(radius = 10.0) {
+        const playerPed = this.platform.getLocalPlayerPed();
+        return this.platform.getClosestVehicle(this.platform.getEntityCoords(playerPed), radius);
+    }
+    isPlayerInVehicle() {
+        return this.platform.isPedInAnyVehicle(this.platform.getLocalPlayerPed());
+    }
+    getCurrentVehicle() {
+        const ped = this.platform.getLocalPlayerPed();
+        if (!this.platform.isPedInAnyVehicle(ped))
+            return null;
+        return this.platform.getVehiclePedIsIn(ped, false);
+    }
+    getLastVehicle() {
+        return this.platform.getVehiclePedIsIn(this.platform.getLocalPlayerPed(), true);
+    }
+    isPlayerDriver() {
+        const vehicle = this.getCurrentVehicle();
+        if (!vehicle)
+            return false;
+        return this.platform.getPedInVehicleSeat(vehicle, -1) === this.platform.getLocalPlayerPed();
+    }
+    getSpeed(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return 0;
+        return this.platform.getEntitySpeed(vehicle) * 3.6;
+    }
+    getNetworkId(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return 0;
+        return this.platform.networkGetNetworkIdFromEntity(vehicle);
+    }
+    getVehicleFromNetworkId(networkId) {
+        if (!this.platform.networkDoesEntityExistWithNetworkId(networkId))
+            return 0;
+        return this.platform.networkGetEntityFromNetworkId(networkId);
+    }
+    getVehicleState(vehicle, key) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return undefined;
+        return this.platform.getEntityState(vehicle, key);
+    }
+    setDoorsLocked(networkId, locked) {
+        this.events.emit('opencore:vehicle:setLocked', networkId, locked);
+    }
+    async getVehicleData(networkId) {
+        return new Promise((resolve) => {
+            this.pendingData.set(networkId, resolve);
+            this.events.emit('opencore:vehicle:getData', networkId);
+            setTimeout(() => {
+                if (!this.pendingData.has(networkId))
+                    return;
+                this.pendingData.delete(networkId);
+                resolve(null);
+            }, 5000);
+        });
+    }
+    async getPlayerVehicles() {
+        return new Promise((resolve) => {
+            this.pendingPlayerVehicles = resolve;
+            this.events.emit('opencore:vehicle:getPlayerVehicles');
+            setTimeout(() => {
+                if (!this.pendingPlayerVehicles)
+                    return;
+                this.pendingPlayerVehicles = null;
+                resolve([]);
+            }, 5000);
+        });
+    }
+    warpIntoVehicle(vehicle, seatIndex = -1) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return;
+        this.platform.taskWarpPedIntoVehicle(this.platform.getLocalPlayerPed(), vehicle, seatIndex);
+    }
+    setHeading(vehicle, heading) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return;
+        this.platform.setEntityHeading(vehicle, heading);
+    }
+    getPosition(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return null;
+        return this.platform.getEntityCoords(vehicle);
+    }
+    getHeading(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return 0;
+        return this.platform.getEntityHeading(vehicle);
+    }
+    getModel(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return 0;
+        return this.platform.getEntityModel(vehicle);
+    }
+    getPlate(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return '';
+        return this.platform.getVehicleNumberPlateText(vehicle);
+    }
+    applyMods(vehicle, mods) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return;
+        this.platform.setVehicleModKit(vehicle, 0);
+        if (mods.spoiler !== undefined)
+            this.platform.setVehicleMod(vehicle, 0, mods.spoiler, false);
+        if (mods.frontBumper !== undefined)
+            this.platform.setVehicleMod(vehicle, 1, mods.frontBumper, false);
+        if (mods.rearBumper !== undefined)
+            this.platform.setVehicleMod(vehicle, 2, mods.rearBumper, false);
+        if (mods.sideSkirt !== undefined)
+            this.platform.setVehicleMod(vehicle, 3, mods.sideSkirt, false);
+        if (mods.exhaust !== undefined)
+            this.platform.setVehicleMod(vehicle, 4, mods.exhaust, false);
+        if (mods.frame !== undefined)
+            this.platform.setVehicleMod(vehicle, 5, mods.frame, false);
+        if (mods.grille !== undefined)
+            this.platform.setVehicleMod(vehicle, 6, mods.grille, false);
+        if (mods.hood !== undefined)
+            this.platform.setVehicleMod(vehicle, 7, mods.hood, false);
+        if (mods.fender !== undefined)
+            this.platform.setVehicleMod(vehicle, 8, mods.fender, false);
+        if (mods.rightFender !== undefined)
+            this.platform.setVehicleMod(vehicle, 9, mods.rightFender, false);
+        if (mods.roof !== undefined)
+            this.platform.setVehicleMod(vehicle, 10, mods.roof, false);
+        if (mods.engine !== undefined)
+            this.platform.setVehicleMod(vehicle, 11, mods.engine, false);
+        if (mods.brakes !== undefined)
+            this.platform.setVehicleMod(vehicle, 12, mods.brakes, false);
+        if (mods.transmission !== undefined)
+            this.platform.setVehicleMod(vehicle, 13, mods.transmission, false);
+        if (mods.horns !== undefined)
+            this.platform.setVehicleMod(vehicle, 14, mods.horns, false);
+        if (mods.suspension !== undefined)
+            this.platform.setVehicleMod(vehicle, 15, mods.suspension, false);
+        if (mods.armor !== undefined)
+            this.platform.setVehicleMod(vehicle, 16, mods.armor, false);
+        if (mods.turbo !== undefined)
+            this.platform.toggleVehicleMod(vehicle, 18, mods.turbo);
+        if (mods.xenon !== undefined)
+            this.platform.toggleVehicleMod(vehicle, 22, mods.xenon);
+        if (mods.wheelType !== undefined)
+            this.platform.setVehicleWheelType(vehicle, mods.wheelType);
+        if (mods.wheels !== undefined)
+            this.platform.setVehicleMod(vehicle, 23, mods.wheels, false);
+        if (mods.windowTint !== undefined)
+            this.platform.setVehicleWindowTint(vehicle, mods.windowTint);
+        if (mods.livery !== undefined)
+            this.platform.setVehicleLivery(vehicle, mods.livery);
+        if (mods.plateStyle !== undefined)
+            this.platform.setVehicleNumberPlateTextIndex(vehicle, mods.plateStyle);
+        if (mods.neonEnabled !== undefined) {
+            this.platform.setVehicleNeonLightEnabled(vehicle, 0, mods.neonEnabled[0]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 1, mods.neonEnabled[1]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 2, mods.neonEnabled[2]);
+            this.platform.setVehicleNeonLightEnabled(vehicle, 3, mods.neonEnabled[3]);
+        }
+        if (mods.neonColor !== undefined) {
+            this.platform.setVehicleNeonLightsColour(vehicle, mods.neonColor[0], mods.neonColor[1], mods.neonColor[2]);
+        }
+        if (mods.extras) {
+            for (const [extraId, enabled] of Object.entries(mods.extras)) {
+                this.platform.setVehicleExtra(vehicle, Number(extraId), !enabled);
+            }
+        }
+        if (mods.pearlescentColor !== undefined || mods.wheelColor !== undefined) {
+            const [currentPearl, currentWheel] = this.platform.getVehicleExtraColours(vehicle);
+            this.platform.setVehicleExtraColours(vehicle, mods.pearlescentColor ?? currentPearl, mods.wheelColor ?? currentWheel);
+        }
+    }
+    repair(vehicle) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return;
+        this.platform.setVehicleFixed(vehicle);
+        this.platform.setVehicleDeformationFixed(vehicle);
+        this.platform.setVehicleUndriveable(vehicle, false);
+        this.platform.setVehicleEngineOn(vehicle, true, true, false);
+        this.platform.setVehicleEngineHealth(vehicle, 1000.0);
+        this.platform.setVehiclePetrolTankHealth(vehicle, 1000.0);
+    }
+    setFuel(vehicle, level) {
+        if (!this.platform.doesEntityExist(vehicle))
+            return;
+        this.platform.setVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level)));
+    }
+    registerEventHandlers() {
+        this.events.on('opencore:vehicle:createResult', (_ctx, result) => {
+            if (result._requestId === undefined)
+                return;
+            const callback = this.pendingCreations.get(result._requestId);
+            if (!callback)
+                return;
+            callback(result);
+            this.pendingCreations.delete(result._requestId);
+        });
+        this.events.on('opencore:vehicle:deleteResult', (_ctx, result) => {
+            const callback = this.pendingDeletes.get(result.networkId);
+            if (!callback)
+                return;
+            callback(result.success);
+            this.pendingDeletes.delete(result.networkId);
+        });
+        this.events.on('opencore:vehicle:repairResult', (_ctx, result) => {
+            const callback = this.pendingRepairs.get(result.networkId);
+            if (!callback)
+                return;
+            callback(result.success);
+            this.pendingRepairs.delete(result.networkId);
+        });
+        this.events.on('opencore:vehicle:dataResult', (_ctx, data) => {
+            if (!data)
+                return;
+            const callback = this.pendingData.get(data.networkId);
+            if (!callback)
+                return;
+            callback(data);
+            this.pendingData.delete(data.networkId);
+        });
+        this.events.on('opencore:vehicle:playerVehiclesResult', (_ctx, vehicles) => {
+            this.pendingPlayerVehicles?.(vehicles);
+            this.pendingPlayerVehicles = null;
+        });
+        this.events.on('opencore:vehicle:created', async (_ctx, data) => {
+            const veh = await this.waitForVehicle(data.networkId);
+            if (!veh)
+                return;
+            if (data.mods && Object.keys(data.mods).length > 0)
+                this.applyMods(veh, data.mods);
+            if (data.metadata?.fuel !== undefined)
+                this.setFuel(veh, data.metadata.fuel);
+        });
+        this.events.on('opencore:vehicle:modified', (_ctx, data) => {
+            const veh = this.getVehicleFromNetworkId(data.networkId);
+            if (veh && this.platform.doesEntityExist(veh))
+                this.applyMods(veh, data.mods);
+        });
+        this.events.on('opencore:vehicle:repaired', (_ctx, networkId) => {
+            const veh = this.getVehicleFromNetworkId(networkId);
+            if (veh && this.platform.doesEntityExist(veh))
+                this.repair(veh);
+        });
+        this.events.on('opencore:vehicle:warpInto', async (_ctx, networkId, seatIndex = -1) => {
+            const veh = await this.waitForVehicle(networkId);
+            if (veh)
+                this.warpIntoVehicle(veh, seatIndex);
+        });
+    }
+    async waitForVehicle(networkId) {
+        const started = this.runtime.getGameTimer();
+        while (this.runtime.getGameTimer() - started < 5000) {
+            const veh = this.getVehicleFromNetworkId(networkId);
+            if (veh && this.platform.doesEntityExist(veh))
+                return veh;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        return null;
+    }
+};
+VehicleClientService = __decorate([
+    injectable(),
+    __param(0, inject(EventsAPI)),
+    __param(1, inject(IClientPlatformBridge)),
+    __param(2, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [EventsAPI,
+        IClientPlatformBridge,
+        IClientRuntimeBridge])
+], VehicleClientService);
+export { VehicleClientService };

package/dist/runtime/client/services/vehicle.service.d.ts

@@ -0,0 +1,62 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+export interface VehicleSpawnOptions {
+    model: string;
+    position: Vector3;
+    heading?: number;
+    placeOnGround?: boolean;
+    warpIntoVehicle?: boolean;
+    seatIndex?: number;
+    primaryColor?: number;
+    secondaryColor?: number;
+    plate?: string;
+    networked?: boolean;
+}
+export interface VehicleMods {
+    spoiler?: number;
+    frontBumper?: number;
+    rearBumper?: number;
+    sideSkirt?: number;
+    exhaust?: number;
+    frame?: number;
+    grille?: number;
+    hood?: number;
+    fender?: number;
+    rightFender?: number;
+    roof?: number;
+    engine?: number;
+    brakes?: number;
+    transmission?: number;
+    horns?: number;
+    suspension?: number;
+    armor?: number;
+    turbo?: boolean;
+    xenon?: boolean;
+    wheelType?: number;
+    wheels?: number;
+    windowTint?: number;
+    livery?: number;
+    plateStyle?: number;
+}
+export declare class VehicleService {
+    private readonly platform;
+    constructor(platform: IClientPlatformBridge);
+    spawn(options: VehicleSpawnOptions): Promise<number>;
+    delete(vehicle: number): void;
+    deleteCurrentVehicle(): void;
+    repair(vehicle: number): void;
+    setFuel(vehicle: number, level: number): void;
+    getFuel(vehicle: number): number;
+    getClosest(radius?: number): number | null;
+    isPlayerInVehicle(): boolean;
+    getCurrentVehicle(): number | null;
+    getLastVehicle(): number | null;
+    isPlayerDriver(): boolean;
+    setMods(vehicle: number, mods: VehicleMods): void;
+    setDoorsLocked(vehicle: number, locked: boolean): void;
+    setEngineRunning(vehicle: number, running: boolean, instant?: boolean): void;
+    setInvincible(vehicle: number, invincible: boolean): void;
+    getSpeed(vehicle: number): number;
+    setHeading(vehicle: number, heading: number): void;
+    teleport(vehicle: number, position: Vector3, heading?: number): void;
+}