@open-core/framework 0.1.0-alpha.1 → 0.2.0-beta.1

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

@@ -0,0 +1,328 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppearanceService = void 0;
+const tsyringe_1 = require("tsyringe");
+const IHasher_1 = require("../../../adapters/contracts/IHasher");
+const IPedAppearanceClient_1 = require("../../../adapters/contracts/IPedAppearanceClient");
+/**
+ * Client-side appearance management service.
+ *
+ * @remarks
+ * Handles applying and retrieving ped appearance data on the client.
+ * Uses adapters for FiveM native abstraction, enabling testability.
+ *
+ * This service is typically called in response to server events
+ * after the server has validated the appearance data.
+ *
+ * @example
+ * ```typescript
+ * // Apply appearance from server-validated data
+ * await appearanceService.applyAppearance(PlayerPedId(), validatedAppearance)
+ *
+ * // Get current appearance for saving
+ * const currentAppearance = await appearanceService.getAppearance(PlayerPedId())
+ * ```
+ */
+let AppearanceService = class AppearanceService {
+    constructor(pedAdapter, hasher) {
+        this.pedAdapter = pedAdapter;
+        this.hasher = hasher;
+    }
+    /**
+     * Applies a complete appearance to a ped.
+     *
+     * @remarks
+     * The order of application is important:
+     * 1. HeadBlend (required before overlays/features)
+     * 2. Face features
+     * 3. Components
+     * 4. Props
+     * 5. Head overlays with colors
+     * 6. Hair color
+     * 7. Eye color
+     * 8. Tattoos
+     *
+     * @param ped - Ped entity handle
+     * @param appearance - Appearance data to apply
+     */
+    async applyAppearance(ped, appearance) {
+        var _a;
+        // 1. HeadBlend must be set first (required for overlays and face features)
+        if (appearance.headBlend) {
+            this.pedAdapter.setHeadBlendData(ped, appearance.headBlend);
+        }
+        // 2. Face features (requires headBlend)
+        if (appearance.faceFeatures) {
+            for (const [index, value] of Object.entries(appearance.faceFeatures)) {
+                this.pedAdapter.setFaceFeature(ped, parseInt(index, 10), value);
+            }
+        }
+        // 3. Components (clothing, hair, etc.)
+        if (appearance.components) {
+            for (const [componentId, data] of Object.entries(appearance.components)) {
+                this.pedAdapter.setComponentVariation(ped, parseInt(componentId, 10), data.drawable, data.texture, 2);
+            }
+        }
+        // 4. Props (hats, glasses, etc.)
+        if (appearance.props) {
+            for (const [propId, data] of Object.entries(appearance.props)) {
+                if (data.drawable === -1) {
+                    this.pedAdapter.clearProp(ped, parseInt(propId, 10));
+                }
+                else {
+                    this.pedAdapter.setPropIndex(ped, parseInt(propId, 10), data.drawable, data.texture, true);
+                }
+            }
+        }
+        // 5. Head overlays with colors (requires headBlend)
+        if (appearance.headOverlays) {
+            for (const [overlayId, overlay] of Object.entries(appearance.headOverlays)) {
+                const id = parseInt(overlayId, 10);
+                this.pedAdapter.setHeadOverlay(ped, id, overlay.index, overlay.opacity);
+                if (overlay.colorType !== undefined && overlay.colorId !== undefined) {
+                    this.pedAdapter.setHeadOverlayColor(ped, id, overlay.colorType, overlay.colorId, (_a = overlay.secondColorId) !== null && _a !== void 0 ? _a : overlay.colorId);
+                }
+            }
+        }
+        // 6. Hair color
+        if (appearance.hairColor) {
+            this.pedAdapter.setHairColor(ped, appearance.hairColor.colorId, appearance.hairColor.highlightColorId);
+        }
+        // 7. Eye color
+        if (appearance.eyeColor !== undefined) {
+            this.pedAdapter.setEyeColor(ped, appearance.eyeColor);
+        }
+        // 8. Tattoos
+        if (appearance.tattoos && appearance.tattoos.length > 0) {
+            this.pedAdapter.clearDecorations(ped);
+            for (const tattoo of appearance.tattoos) {
+                const collectionHash = this.hasher.getHashKey(tattoo.collection);
+                const overlayHash = this.hasher.getHashKey(tattoo.overlay);
+                this.pedAdapter.addDecoration(ped, collectionHash, overlayHash);
+            }
+        }
+    }
+    /**
+     * Retrieves the current appearance of a ped.
+     *
+     * @remarks
+     * Only retrieves components and props as other data (headBlend, overlays, etc.)
+     * cannot be read back from the game.
+     *
+     * @param ped - Ped entity handle
+     * @returns Partial appearance data (components and props only)
+     */
+    async getAppearance(ped) {
+        const appearance = {
+            components: {},
+            props: {},
+        };
+        // Components (0-11)
+        for (let i = 0; i <= 11; i++) {
+            const drawable = this.pedAdapter.getDrawableVariation(ped, i);
+            const texture = this.pedAdapter.getTextureVariation(ped, i);
+            if (drawable !== -1) {
+                appearance.components[i] = { drawable, texture };
+            }
+        }
+        // Props (0-7)
+        for (let i = 0; i <= 7; i++) {
+            const drawable = this.pedAdapter.getPropIndex(ped, i);
+            const texture = this.pedAdapter.getPropTextureIndex(ped, i);
+            if (drawable !== -1) {
+                appearance.props[i] = { drawable, texture };
+            }
+        }
+        return appearance;
+    }
+    /**
+     * Gets the number of available drawable variations for a component.
+     *
+     * @param ped - Ped entity handle
+     * @param componentId - Component ID (0-11)
+     * @returns Number of available drawables
+     */
+    getNumComponentDrawables(ped, componentId) {
+        return this.pedAdapter.getNumDrawableVariations(ped, componentId);
+    }
+    /**
+     * Gets the number of available texture variations for a component drawable.
+     *
+     * @param ped - Ped entity handle
+     * @param componentId - Component ID (0-11)
+     * @param drawable - Drawable index
+     * @returns Number of available textures
+     */
+    getNumComponentTextures(ped, componentId, drawable) {
+        return this.pedAdapter.getNumTextureVariations(ped, componentId, drawable);
+    }
+    /**
+     * Gets the number of available drawable variations for a prop.
+     *
+     * @param ped - Ped entity handle
+     * @param propId - Prop ID (0-7)
+     * @returns Number of available drawables
+     */
+    getNumPropDrawables(ped, propId) {
+        return this.pedAdapter.getNumPropDrawableVariations(ped, propId);
+    }
+    /**
+     * Gets the number of available texture variations for a prop drawable.
+     *
+     * @param ped - Ped entity handle
+     * @param propId - Prop ID (0-7)
+     * @param drawable - Drawable index
+     * @returns Number of available textures
+     */
+    getNumPropTextures(ped, propId, drawable) {
+        return this.pedAdapter.getNumPropTextureVariations(ped, propId, drawable);
+    }
+    /**
+     * Gets the number of available overlay variations.
+     *
+     * @param overlayId - Overlay ID (0-12)
+     * @returns Number of available variations
+     */
+    getNumOverlayValues(overlayId) {
+        return this.pedAdapter.getNumOverlayValues(overlayId);
+    }
+    /**
+     * Gets the number of available hair colors.
+     *
+     * @returns Number of hair colors
+     */
+    getNumHairColors() {
+        return this.pedAdapter.getNumHairColors();
+    }
+    /**
+     * Gets the number of available makeup colors.
+     *
+     * @returns Number of makeup colors
+     */
+    getNumMakeupColors() {
+        return this.pedAdapter.getNumMakeupColors();
+    }
+    /**
+     * Validates appearance data structure.
+     *
+     * @remarks
+     * This is a client-side validation for data integrity.
+     * Server-side validation should always be performed for security.
+     *
+     * @param appearance - Appearance data to validate
+     * @returns Validation result with errors if any
+     */
+    validateAppearance(appearance) {
+        const errors = [];
+        if (!appearance) {
+            return { valid: false, errors: ['Appearance data is null or undefined'] };
+        }
+        // Validate components (0-11)
+        if (appearance.components) {
+            for (const [id, data] of Object.entries(appearance.components)) {
+                const componentId = parseInt(id, 10);
+                if (Number.isNaN(componentId) || componentId < 0 || componentId > 11) {
+                    errors.push(`Invalid component ID: ${id}`);
+                }
+                if (data.drawable === undefined || data.texture === undefined) {
+                    errors.push(`Missing drawable or texture for component ${id}`);
+                }
+            }
+        }
+        // Validate props (0-7)
+        if (appearance.props) {
+            for (const [id, data] of Object.entries(appearance.props)) {
+                const propId = parseInt(id, 10);
+                if (Number.isNaN(propId) || propId < 0 || propId > 7) {
+                    errors.push(`Invalid prop ID: ${id}`);
+                }
+                if (data.drawable === undefined || data.texture === undefined) {
+                    errors.push(`Missing drawable or texture for prop ${id}`);
+                }
+            }
+        }
+        // Validate faceFeatures (0-19, values -1.0 to 1.0)
+        if (appearance.faceFeatures) {
+            for (const [id, value] of Object.entries(appearance.faceFeatures)) {
+                const index = parseInt(id, 10);
+                if (Number.isNaN(index) || index < 0 || index > 19) {
+                    errors.push(`Invalid face feature index: ${id}`);
+                }
+                if (value < -1.0 || value > 1.0) {
+                    errors.push(`Face feature ${id} value out of range: ${value}`);
+                }
+            }
+        }
+        // Validate headBlend
+        if (appearance.headBlend) {
+            const hb = appearance.headBlend;
+            if (hb.shapeFirst < 0 || hb.shapeFirst > 45)
+                errors.push('Invalid shapeFirst (0-45)');
+            if (hb.shapeSecond < 0 || hb.shapeSecond > 45)
+                errors.push('Invalid shapeSecond (0-45)');
+            if (hb.skinFirst < 0 || hb.skinFirst > 45)
+                errors.push('Invalid skinFirst (0-45)');
+            if (hb.skinSecond < 0 || hb.skinSecond > 45)
+                errors.push('Invalid skinSecond (0-45)');
+            if (hb.shapeMix < 0 || hb.shapeMix > 1)
+                errors.push('Invalid shapeMix (0.0-1.0)');
+            if (hb.skinMix < 0 || hb.skinMix > 1)
+                errors.push('Invalid skinMix (0.0-1.0)');
+        }
+        // Validate headOverlays (0-12)
+        if (appearance.headOverlays) {
+            for (const [id, overlay] of Object.entries(appearance.headOverlays)) {
+                const overlayId = parseInt(id, 10);
+                if (Number.isNaN(overlayId) || overlayId < 0 || overlayId > 12) {
+                    errors.push(`Invalid overlay ID: ${id}`);
+                }
+                if (overlay.opacity < 0 || overlay.opacity > 1) {
+                    errors.push(`Invalid overlay opacity for ID ${id}`);
+                }
+            }
+        }
+        // Validate eyeColor (0-31)
+        if (appearance.eyeColor !== undefined) {
+            if (appearance.eyeColor < 0 || appearance.eyeColor > 31) {
+                errors.push(`Invalid eye color: ${appearance.eyeColor} (0-31)`);
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Sets the ped to default component variation.
+     *
+     * @param ped - Ped entity handle
+     */
+    setDefaultAppearance(ped) {
+        this.pedAdapter.setDefaultComponentVariation(ped);
+    }
+    /**
+     * Clears all tattoos from a ped.
+     *
+     * @param ped - Ped entity handle
+     */
+    clearTattoos(ped) {
+        this.pedAdapter.clearDecorations(ped);
+    }
+};
+exports.AppearanceService = AppearanceService;
+exports.AppearanceService = AppearanceService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(IPedAppearanceClient_1.IPedAppearanceClient)),
+    __param(1, (0, tsyringe_1.inject)(IHasher_1.IHasher)),
+    __metadata("design:paramtypes", [IPedAppearanceClient_1.IPedAppearanceClient,
+        IHasher_1.IHasher])
+], AppearanceService);

package/dist/{client → runtime/client}/services/blip.service.d.ts

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../utils';
+import { Vector3 } from '../../../kernel/utils';
 export interface BlipOptions {
     /** Blip sprite ID (icon) */
     sprite?: number;

package/dist/{client → runtime/client}/services/index.d.ts

@@ -1,9 +1,10 @@
-export * from './spawn.service';
 export * from './blip.service';
-export * from './vehicle.service';
-export * from './ped.service';
-export * from './streaming.service';
+export * from './marker.service';
 export * from './notification.service';
+export * from './ped.service';
 export * from './progress.service';
-export * from './marker.service';
+export * from './spawn.service';
+export * from './streaming.service';
 export * from './textui.service';
+export * from './vehicle.service';
+export * from './vehicle-client.service';

package/dist/{client → runtime/client}/services/index.js

@@ -14,12 +14,13 @@ 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("./spawn.service"), exports);
 __exportStar(require("./blip.service"), exports);
-__exportStar(require("./vehicle.service"), exports);
-__exportStar(require("./ped.service"), exports);
-__exportStar(require("./streaming.service"), exports);
+__exportStar(require("./marker.service"), exports);
 __exportStar(require("./notification.service"), exports);
+__exportStar(require("./ped.service"), exports);
 __exportStar(require("./progress.service"), exports);
-__exportStar(require("./marker.service"), exports);
+__exportStar(require("./spawn.service"), exports);
+__exportStar(require("./streaming.service"), exports);
 __exportStar(require("./textui.service"), exports);
+__exportStar(require("./vehicle.service"), exports);
+__exportStar(require("./vehicle-client.service"), exports);

package/dist/{client → runtime/client}/services/marker.service.d.ts

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../utils';
+import { Vector3 } from '../../../kernel/utils';
 export interface MarkerOptions {
     /** Marker type (0-43) */
     type?: number;

package/dist/{client → runtime/client}/services/ped.service.d.ts

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../utils';
+import { Vector3 } from '../../../kernel/utils';
 export interface PedSpawnOptions {
     /** Model name or hash */
     model: string;

package/dist/{client → runtime/client}/services/ped.service.js

@@ -211,15 +211,16 @@ let PedService = class PedService {
     getNearby(position, radius, excludePlayer = true) {
         const peds = [];
         const playerPed = PlayerPedId();
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const [handle, _] = FindFirstPed(0);
-        let ped = handle;
+        const ped = handle;
         do {
             if (!DoesEntityExist(ped))
                 continue;
             if (excludePlayer && ped === playerPed)
                 continue;
             const [ex, ey, ez] = GetEntityCoords(ped, true);
-            const dist = Math.sqrt(Math.pow(ex - position.x, 2) + Math.pow(ey - position.y, 2) + Math.pow(ez - position.z, 2));
+            const dist = Math.sqrt((ex - position.x) ** 2 + (ey - position.y) ** 2 + (ez - position.z) ** 2);
             if (dist <= radius) {
                 peds.push(ped);
             }

package/dist/{client → runtime/client}/services/spawn.service.d.ts

@@ -1,6 +1,6 @@
-import { Vector3 } from '../../utils';
+import { PlayerAppearance } from '../../../kernel/shared';
+import { Vector3 } from '../../../kernel/utils';
 import { AppearanceService } from './appearance.service';
-import { PlayerAppearance } from '../interfaces/appearance.interface';
 interface SpawnOptions {
     /** Optional: Apply complete character appearance (RP clothing, face, props, tattoos...) */
     appearance?: PlayerAppearance;

package/dist/{client → runtime/client}/services/spawn.service.js

@@ -11,7 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpawnService = void 0;
 const tsyringe_1 = require("tsyringe");
-const shared_1 = require("../../shared");
+const shared_1 = require("../../../kernel/shared");
 const appearance_service_1 = require("./appearance.service");
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const NETWORK_TIMEOUT_MS = 15000;
@@ -111,10 +111,6 @@ let SpawnService = class SpawnService {
             SetEntityHeading(ped, heading);
         }
         FreezeEntityPosition(ped, false);
-        shared_1.loggers.spawn.debug('Teleported', {
-            position: { x: position.x, y: position.y, z: position.z },
-            heading,
-        });
     }
     /**
      * Respawns the player after death or a gameplay event.
@@ -185,7 +181,6 @@ let SpawnService = class SpawnService {
         if (ped !== 0) {
             SetPedDefaultComponentVariation(ped);
         }
-        shared_1.loggers.spawn.debug('Player model set', { model, modelHash });
     }
     async ensurePed() {
         const start = GetGameTimer();
@@ -225,7 +220,6 @@ let SpawnService = class SpawnService {
         SetEntityVisible(ped, true, false);
         SetEntityCollision(ped, true, true);
         SetEntityInvincible(ped, false);
-        shared_1.loggers.spawn.debug('Ped prepared for gameplay', { ped });
     }
     async placePed(ped, position, heading) {
         FreezeEntityPosition(ped, true);
@@ -239,7 +233,9 @@ let SpawnService = class SpawnService {
             SetPedDefaultComponentVariation(ped);
             return;
         }
-        if (!this.appearanceService.validateAppearance(appearance)) {
+        const validation = this.appearanceService.validateAppearance(appearance);
+        if (!validation.valid) {
+            shared_1.loggers.spawn.warn('Invalid appearance data', { errors: validation.errors });
             SetPedDefaultComponentVariation(ped);
             return;
         }

package/dist/{client → runtime/client}/services/textui.service.d.ts

@@ -1,4 +1,4 @@
-import type { Vector3 } from '../../utils';
+import { Vector3 } from '../../../kernel/utils';
 export interface TextUIOptions {
     /** Font (0-8) */
     font?: number;

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

@@ -0,0 +1,180 @@
+import { Vector3 } from '../../../kernel/utils';
+import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../../server/types/vehicle.types';
+/**
+ * Client-side vehicle service.
+ *
+ * This service provides a simplified interface for vehicle operations on the client.
+ * Most operations delegate to the server for security and synchronization.
+ *
+ * @remarks
+ * - Vehicle creation is server-authoritative (prevents spawning exploits)
+ * - Modifications require server validation
+ * - Local operations (queries, visual changes) are safe to perform client-side
+ */
+export declare class VehicleClientService {
+    private pendingCreations;
+    private requestIdCounter;
+    constructor();
+    /**
+     * Requests vehicle creation from the server.
+     *
+     * @param options - Vehicle creation options
+     * @returns Promise resolving to spawn result
+     */
+    createVehicle(options: Omit<VehicleCreateOptions, 'ownership'>): Promise<VehicleSpawnResult>;
+    /**
+     * Requests vehicle deletion from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to success status
+     */
+    deleteVehicle(networkId: number): Promise<boolean>;
+    /**
+     * Requests vehicle repair from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to success status
+     */
+    repairVehicle(networkId: number): Promise<boolean>;
+    /**
+     * Gets the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosestVehicle(radius?: number): number | null;
+    /**
+     * Checks if the player is in a vehicle.
+     */
+    isPlayerInVehicle(): boolean;
+    /**
+     * Gets the vehicle the player is currently in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getCurrentVehicle(): number | null;
+    /**
+     * Gets the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle(): number | null;
+    /**
+     * Checks if player is the driver of their current vehicle.
+     */
+    isPlayerDriver(): boolean;
+    /**
+     * Gets vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle: number): number;
+    /**
+     * Gets the network ID from a vehicle handle.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Network ID or 0 if invalid
+     */
+    getNetworkId(vehicle: number): number;
+    /**
+     * Gets the vehicle handle from a network ID.
+     *
+     * @param networkId - Network ID
+     * @returns Vehicle handle or 0 if not found
+     */
+    getVehicleFromNetworkId(networkId: number): number;
+    /**
+     * Gets vehicle data from state bag.
+     *
+     * @param vehicle - Vehicle handle
+     * @param key - State bag key
+     * @returns State value or undefined
+     */
+    getVehicleState<T = any>(vehicle: number, key: string): T | undefined;
+    /**
+     * Requests to lock/unlock vehicle doors.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param locked - Whether to lock or unlock
+     */
+    setDoorsLocked(networkId: number, locked: boolean): void;
+    /**
+     * Requests vehicle data from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to vehicle data
+     */
+    getVehicleData(networkId: number): Promise<SerializedVehicleData | null>;
+    /**
+     * Requests all player vehicles from the server.
+     *
+     * @returns Promise resolving to array of vehicle data
+     */
+    getPlayerVehicles(): Promise<SerializedVehicleData[]>;
+    /**
+     * Local-only: Warps player into a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param seatIndex - Seat index (-1 = driver)
+     */
+    warpIntoVehicle(vehicle: number, seatIndex?: number): void;
+    /**
+     * Local-only: Sets vehicle heading.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle: number, heading: number): void;
+    /**
+     * Local-only: Gets vehicle position.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Position vector
+     */
+    getPosition(vehicle: number): Vector3 | null;
+    /**
+     * Local-only: Gets vehicle heading.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Heading in degrees
+     */
+    getHeading(vehicle: number): number;
+    /**
+     * Local-only: Gets vehicle model hash.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Model hash
+     */
+    getModel(vehicle: number): number;
+    /**
+     * Local-only: Gets vehicle license plate.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns License plate text
+     */
+    getPlate(vehicle: number): string;
+    /**
+     * Applies vehicle mods from state bag data.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Mods object from state bag
+     */
+    applyMods(vehicle: number, mods: Record<string, any>): void;
+    /**
+     * Repairs a vehicle completely (client-side).
+     *
+     * @param vehicle - Vehicle handle
+     */
+    repair(vehicle: number): void;
+    /**
+     * Sets fuel level on a vehicle (client-side).
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0-100)
+     */
+    setFuel(vehicle: number, level: number): void;
+    /**
+     * Registers event handlers for server responses.
+     */
+    private registerEventHandlers;
+}