@open-core/ragemp-adapter 0.1.0

package/dist/client/native-chat.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableRageMPNativeChat = enableRageMPNativeChat;
+const nativeChatGlobal = globalThis;
+const CHAT_TYPE_COLORS = {
+    chat: { r: 255, g: 255, b: 255 },
+    error: { r: 224, g: 62, b: 62 },
+    success: { r: 88, g: 196, b: 110 },
+    warning: { r: 232, g: 181, b: 55 },
+};
+function toHex(color) {
+    const part = (value) => Math.max(0, Math.min(255, value)).toString(16).padStart(2, '0');
+    return `${part(color.r)}${part(color.g)}${part(color.b)}`;
+}
+function pushNativeChatLine(text, color) {
+    try {
+        mp.gui.chat.activate(true);
+        mp.gui.chat.show(true);
+        mp.gui.chat.push(`!{${toHex(color)}}${text}`);
+    }
+    catch {
+        // Ignore chat output when RageMP chat runtime is not ready yet.
+    }
+}
+function formatPayload(payload) {
+    const [author, message] = payload.args ?? ['SYSTEM', ''];
+    return {
+        text: author ? `${author}: ${message}` : String(message),
+        color: payload.color ?? CHAT_TYPE_COLORS.chat,
+    };
+}
+function enableRageMPNativeChat(events) {
+    if (nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_ENABLED__)
+        return;
+    nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_ENABLED__ = true;
+    events.on('core:chat:addMessage', (_ctx, payload) => {
+        const { text, color } = formatPayload(payload);
+        pushNativeChatLine(text, color);
+    });
+    events.on('core:chat:message', (_ctx, payload) => {
+        const { text, color } = formatPayload(payload);
+        pushNativeChatLine(text, color);
+    });
+    events.on('core:chat:send', (_ctx, message, type = 'chat') => {
+        pushNativeChatLine(message, CHAT_TYPE_COLORS[type] ?? CHAT_TYPE_COLORS.chat);
+    });
+    events.on('core:chat:clear', () => {
+        // RageMP native chat has no public clear API.
+    });
+}

package/dist/client/ragemp-blip-bridge.d.ts

@@ -0,0 +1,12 @@
+import { IClientBlipBridge, type ClientBlipDefinition } from '@open-core/framework/contracts/client';
+export declare class RageMPClientBlipBridge extends IClientBlipBridge {
+    private readonly blips;
+    private readonly definitions;
+    create(id: string, definition: ClientBlipDefinition): void;
+    update(id: string, patch: Partial<ClientBlipDefinition>): boolean;
+    exists(id: string): boolean;
+    remove(id: string): boolean;
+    clear(): void;
+    private createRef;
+    private apply;
+}

package/dist/client/ragemp-blip-bridge.js

@@ -0,0 +1,139 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientBlipBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+function toVector3(position) {
+    return new mp.Vector3(position.x, position.y, position.z);
+}
+let RageMPClientBlipBridge = class RageMPClientBlipBridge extends client_1.IClientBlipBridge {
+    constructor() {
+        super(...arguments);
+        this.blips = new Map();
+        this.definitions = new Map();
+    }
+    create(id, definition) {
+        this.remove(id);
+        const ref = this.createRef(definition);
+        if (!ref)
+            return;
+        this.blips.set(id, ref);
+        this.definitions.set(id, { ...definition });
+        this.apply(id, definition);
+    }
+    update(id, patch) {
+        const current = this.definitions.get(id);
+        if (!current)
+            return false;
+        const next = { ...current, ...patch };
+        const changedAnchor = patch.position !== undefined || patch.entity !== undefined || patch.radius !== undefined;
+        if (changedAnchor) {
+            this.create(id, next);
+            return this.exists(id);
+        }
+        this.definitions.set(id, next);
+        this.apply(id, next);
+        return true;
+    }
+    exists(id) {
+        return this.blips.has(id);
+    }
+    remove(id) {
+        const ref = this.blips.get(id);
+        if (!ref)
+            return false;
+        if (ref.kind === 'mp')
+            ref.blip.destroy();
+        else
+            mp.game.ui.removeBlip(ref.handle);
+        this.blips.delete(id);
+        this.definitions.delete(id);
+        return true;
+    }
+    clear() {
+        for (const id of this.blips.keys())
+            this.remove(id);
+    }
+    createRef(definition) {
+        if (definition.entity !== undefined) {
+            return { kind: 'native', handle: mp.game.ui.addBlipForEntity(definition.entity) };
+        }
+        if (definition.radius !== undefined && definition.position) {
+            return {
+                kind: 'native',
+                handle: mp.game.ui.addBlipForRadius(definition.position.x, definition.position.y, definition.position.z, definition.radius),
+            };
+        }
+        if (!definition.position)
+            return null;
+        return {
+            kind: 'mp',
+            blip: mp.blips.new(definition.icon ?? 1, toVector3(definition.position), {
+                color: definition.color,
+                scale: definition.scale,
+                shortRange: definition.shortRange,
+                name: definition.label,
+                alpha: definition.alpha,
+            }),
+        };
+    }
+    apply(id, definition) {
+        const ref = this.blips.get(id);
+        if (!ref)
+            return;
+        if (ref.kind === 'mp') {
+            if (definition.position)
+                ref.blip.setCoords(toVector3(definition.position));
+            if (definition.icon !== undefined)
+                ref.blip.setSprite(definition.icon);
+            if (definition.color !== undefined)
+                ref.blip.setColour(definition.color);
+            if (definition.scale !== undefined)
+                ref.blip.setScale(definition.scale);
+            if (definition.shortRange !== undefined)
+                ref.blip.setAsShortRange(definition.shortRange);
+            if (definition.route !== undefined)
+                ref.blip.setRoute(definition.route);
+            if (definition.routeColor !== undefined)
+                ref.blip.setRouteColour(definition.routeColor);
+            if (definition.alpha !== undefined)
+                ref.blip.setAlpha(definition.alpha);
+            if (definition.visible !== undefined)
+                ref.blip.setDisplay(definition.visible ? 4 : 0);
+            if (definition.label) {
+                ;
+                ref.blip.name = definition.label;
+            }
+            return;
+        }
+        const handle = ref.handle;
+        if (definition.position)
+            mp.game.ui.setBlipCoords(handle, definition.position.x, definition.position.y, definition.position.z);
+        if (definition.icon !== undefined)
+            mp.game.ui.setBlipSprite(handle, definition.icon);
+        if (definition.color !== undefined)
+            mp.game.ui.setBlipColour(handle, definition.color);
+        if (definition.scale !== undefined)
+            mp.game.ui.setBlipScale(handle, definition.scale);
+        if (definition.shortRange !== undefined)
+            mp.game.ui.setBlipAsShortRange(handle, definition.shortRange);
+        if (definition.route !== undefined)
+            mp.game.ui.setBlipRoute(handle, definition.route);
+        if (definition.routeColor !== undefined)
+            mp.game.ui.setBlipRouteColour(handle, definition.routeColor);
+        if (definition.alpha !== undefined)
+            mp.game.ui.setBlipAlpha(handle, definition.alpha);
+        if (definition.visible !== undefined)
+            mp.game.ui.setBlipDisplay(handle, definition.visible ? 4 : 0);
+    }
+};
+exports.RageMPClientBlipBridge = RageMPClientBlipBridge;
+exports.RageMPClientBlipBridge = RageMPClientBlipBridge = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientBlipBridge);

package/dist/client/ragemp-hasher.d.ts

@@ -0,0 +1,4 @@
+import { IHasher } from '@open-core/framework/contracts';
+export declare class RageMPClientHasher extends IHasher {
+    getHashKey(str: string): number;
+}

package/dist/client/ragemp-hasher.js

@@ -0,0 +1,20 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientHasher = void 0;
+const tsyringe_1 = require("tsyringe");
+const contracts_1 = require("@open-core/framework/contracts");
+let RageMPClientHasher = class RageMPClientHasher extends contracts_1.IHasher {
+    getHashKey(str) {
+        return mp.game.joaat(str);
+    }
+};
+exports.RageMPClientHasher = RageMPClientHasher;
+exports.RageMPClientHasher = RageMPClientHasher = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientHasher);

package/dist/client/ragemp-local-player-bridge.d.ts

@@ -0,0 +1,8 @@
+import { IClientLocalPlayerBridge } from '@open-core/framework/contracts/client';
+import type { Vector3 } from '@open-core/framework/kernel';
+/**
+ * RAGE Multiplayer implementation of local player movement helpers.
+ */
+export declare class RageMPLocalPlayerBridge extends IClientLocalPlayerBridge {
+    setPosition(position: Vector3, heading?: number): void;
+}

package/dist/client/ragemp-local-player-bridge.js

@@ -0,0 +1,26 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPLocalPlayerBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+/**
+ * RAGE Multiplayer implementation of local player movement helpers.
+ */
+let RageMPLocalPlayerBridge = class RageMPLocalPlayerBridge extends client_1.IClientLocalPlayerBridge {
+    setPosition(position, heading) {
+        mp.players.local.position = new mp.Vector3(position.x, position.y, position.z);
+        if (typeof heading === 'number') {
+            mp.players.local.heading = heading;
+        }
+    }
+};
+exports.RageMPLocalPlayerBridge = RageMPLocalPlayerBridge;
+exports.RageMPLocalPlayerBridge = RageMPLocalPlayerBridge = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPLocalPlayerBridge);

package/dist/client/ragemp-log-console.d.ts

@@ -0,0 +1,11 @@
+import { IClientLogConsole, type ClientLogConsoleCapabilities } from '@open-core/framework/contracts/client';
+export declare class RageMPClientLogConsole extends IClientLogConsole {
+    getCapabilities(): ClientLogConsoleCapabilities;
+    trace(message: string, details?: unknown): void;
+    debug(message: string, details?: unknown): void;
+    info(message: string, details?: unknown): void;
+    warn(message: string, details?: unknown): void;
+    error(message: string, details?: unknown): void;
+    private write;
+}
+export declare function installRageMPClientLogConsole(logConsole: IClientLogConsole): void;

package/dist/client/ragemp-log-console.js

@@ -0,0 +1,75 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientLogConsole = void 0;
+exports.installRageMPClientLogConsole = installRageMPClientLogConsole;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+const kernel_1 = require("@open-core/framework/kernel");
+const RAGEMP_CLIENT_LOG_CAPABILITIES = {
+    supportsColors: false,
+    supportsStructuredData: false,
+    supportsRichFormatting: false,
+};
+function stringifyDetails(details) {
+    if (details === undefined)
+        return '';
+    if (typeof details === 'string')
+        return details;
+    try {
+        return JSON.stringify(details);
+    }
+    catch {
+        return String(details);
+    }
+}
+let RageMPClientLogConsole = class RageMPClientLogConsole extends client_1.IClientLogConsole {
+    getCapabilities() {
+        return RAGEMP_CLIENT_LOG_CAPABILITIES;
+    }
+    trace(message, details) {
+        this.write('logInfo', `[TRACE] ${message}`, details);
+    }
+    debug(message, details) {
+        this.write('logInfo', `[DEBUG] ${message}`, details);
+    }
+    info(message, details) {
+        this.write('logInfo', message, details);
+    }
+    warn(message, details) {
+        this.write('logWarning', message, details);
+    }
+    error(message, details) {
+        this.write('logError', message, details);
+    }
+    write(method, message, details) {
+        const suffix = stringifyDetails(details);
+        const output = suffix ? `${message} ${suffix}` : message;
+        try {
+            mp.console[method](output);
+        }
+        catch {
+            if (method === 'logError') {
+                console.error(output);
+            }
+            else if (method === 'logWarning') {
+                console.warn(output);
+            }
+            else {
+                console.info(output);
+            }
+        }
+    }
+};
+exports.RageMPClientLogConsole = RageMPClientLogConsole;
+exports.RageMPClientLogConsole = RageMPClientLogConsole = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientLogConsole);
+function installRageMPClientLogConsole(logConsole) {
+    (0, kernel_1.setClientLogConsole)(logConsole);
+}

package/dist/client/ragemp-marker-bridge.d.ts

@@ -0,0 +1,11 @@
+import { IClientMarkerBridge, type ClientMarkerDefinition } from '@open-core/framework/contracts/client';
+export declare class RageMPClientMarkerBridge extends IClientMarkerBridge {
+    private readonly markers;
+    constructor();
+    create(id: string, definition: ClientMarkerDefinition): void;
+    update(id: string, patch: Partial<ClientMarkerDefinition>): boolean;
+    remove(id: string): boolean;
+    exists(id: string): boolean;
+    clear(): void;
+    draw(definition: ClientMarkerDefinition): void;
+}

package/dist/client/ragemp-marker-bridge.js

@@ -0,0 +1,57 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientMarkerBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+let RageMPClientMarkerBridge = class RageMPClientMarkerBridge extends client_1.IClientMarkerBridge {
+    constructor() {
+        super();
+        this.markers = new Map();
+        mp.events.add('render', () => {
+            for (const marker of this.markers.values()) {
+                if (marker.visible === false)
+                    continue;
+                this.draw(marker);
+            }
+        });
+    }
+    create(id, definition) {
+        this.markers.set(id, { ...definition });
+    }
+    update(id, patch) {
+        const current = this.markers.get(id);
+        if (!current)
+            return false;
+        this.markers.set(id, { ...current, ...patch });
+        return true;
+    }
+    remove(id) {
+        return this.markers.delete(id);
+    }
+    exists(id) {
+        return this.markers.has(id);
+    }
+    clear() {
+        this.markers.clear();
+    }
+    draw(definition) {
+        const rotation = definition.rotation ?? { x: 0, y: 0, z: 0 };
+        const size = definition.size ?? definition.scale ?? { x: 1, y: 1, z: 1 };
+        const color = definition.color ?? { r: 255, g: 0, b: 0, a: 200 };
+        mp.game.graphics.drawMarker(definition.variant ?? definition.type ?? 1, definition.position.x, definition.position.y, definition.position.z, 0, 0, 0, rotation.x, rotation.y, rotation.z, size.x, size.y, size.z, color.r, color.g, color.b, color.a, definition.bob ?? definition.bobUpAndDown ?? false, definition.faceCamera ?? false, 2, definition.rotate ?? false, null, null, definition.drawOnEnts ?? false);
+    }
+};
+exports.RageMPClientMarkerBridge = RageMPClientMarkerBridge;
+exports.RageMPClientMarkerBridge = RageMPClientMarkerBridge = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], RageMPClientMarkerBridge);

package/dist/client/ragemp-notification-bridge.d.ts

@@ -0,0 +1,5 @@
+import { IClientNotificationBridge, type ClientNotificationDefinition } from '@open-core/framework/contracts/client';
+export declare class RageMPClientNotificationBridge extends IClientNotificationBridge {
+    show(definition: ClientNotificationDefinition): void;
+    clear(scope?: 'help' | 'subtitle' | 'all'): void;
+}

package/dist/client/ragemp-notification-bridge.js

@@ -0,0 +1,70 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientNotificationBridge = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+const ICON_MAP = {
+    info: 1,
+    success: 2,
+    warning: 3,
+    error: 4,
+};
+let RageMPClientNotificationBridge = class RageMPClientNotificationBridge extends client_1.IClientNotificationBridge {
+    show(definition) {
+        switch (definition.kind) {
+            case 'feed':
+                mp.game.ui.setNotificationTextEntry('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.drawNotification(definition.blink ?? false, definition.saveToBrief ?? true);
+                return;
+            case 'typed':
+                mp.game.ui.beginTextCommandThefeedPost('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.endTextCommandThefeedPostMessagetext('CHAR_SOCIAL_CLUB', 'CHAR_SOCIAL_CLUB', true, ICON_MAP[definition.type ?? 'info'], '', definition.message);
+                return;
+            case 'advanced':
+                mp.game.ui.setNotificationTextEntry('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.setNotificationMessage('CHAR_HUMANDEFAULT', 'CHAR_HUMANDEFAULT', definition.flash ?? false, ICON_MAP[definition.type ?? 'info'], definition.title ?? '', definition.subtitle ?? '');
+                mp.game.ui.drawNotification(definition.flash ?? false, definition.saveToBrief ?? true);
+                return;
+            case 'help':
+                mp.game.ui.beginTextCommandDisplayHelp('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.endTextCommandDisplayHelp(0, definition.looped ?? false, definition.beep ?? true, definition.duration ?? 5000);
+                return;
+            case 'subtitle':
+                mp.game.ui.beginTextCommandPrint('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.endTextCommandPrint(definition.duration ?? 2500, true);
+                return;
+            case 'floating':
+                if (!definition.worldPosition)
+                    return;
+                mp.game.ui.setFloatingHelpTextWorldPosition(1, definition.worldPosition.x, definition.worldPosition.y, definition.worldPosition.z);
+                mp.game.ui.setFloatingHelpTextStyle(1, 1, 2, -1, 3, 0);
+                mp.game.ui.beginTextCommandDisplayHelp('STRING');
+                mp.game.ui.addTextComponentSubstringPlayerName(definition.message);
+                mp.game.ui.endTextCommandDisplayHelp(2, false, false, -1);
+                return;
+        }
+    }
+    clear(scope) {
+        if (!scope || scope === 'all' || scope === 'help') {
+            mp.game.ui.clearAllHelpMessages();
+        }
+        if (!scope || scope === 'all' || scope === 'subtitle') {
+            mp.game.ui.clearPrints();
+        }
+    }
+};
+exports.RageMPClientNotificationBridge = RageMPClientNotificationBridge;
+exports.RageMPClientNotificationBridge = RageMPClientNotificationBridge = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientNotificationBridge);

package/dist/client/ragemp-platform-bridge.d.ts

@@ -0,0 +1,141 @@
+import { IClientPlatformBridge, IGtaPedAppearanceBridge } from '@open-core/framework/contracts/client';
+import type { Vector3 as CoreVector3 } from '@open-core/framework/kernel';
+import type { HeadBlendData } from '@open-core/framework/kernel';
+export declare class RageMPPedAppearanceClient extends IGtaPedAppearanceBridge {
+    setComponentVariation(ped: number, componentId: number, drawableId: number, textureId: number): void;
+    setPropIndex(ped: number, propId: number, drawableId: number, textureId: number): void;
+    clearProp(ped: number, propId: number): void;
+    setDefaultComponentVariation(ped: number): void;
+    setHeadBlendData(ped: number, data: HeadBlendData): void;
+    setFaceFeature(ped: number, index: number, scale: number): void;
+    setHeadOverlay(ped: number, overlayId: number, index: number, opacity: number): void;
+    setHeadOverlayColor(ped: number, overlayId: number, colorType: number, colorId: number, secondColorId: number): void;
+    setHairColor(ped: number, colorId: number, highlightColorId: number): void;
+    setEyeColor(ped: number, colorId: number): void;
+    addDecoration(ped: number, collectionHash: number, overlayHash: number): void;
+    clearDecorations(ped: number): void;
+    getDrawableVariation(ped: number, componentId: number): number;
+    getTextureVariation(ped: number, componentId: number): number;
+    getPropIndex(ped: number, propId: number): number;
+    getPropTextureIndex(ped: number, propId: number): number;
+    getNumDrawableVariations(ped: number, componentId: number): number;
+    getNumTextureVariations(ped: number, componentId: number, drawableId: number): number;
+    getNumPropDrawableVariations(ped: number, propId: number): number;
+    getNumPropTextureVariations(ped: number, propId: number, drawableId: number): number;
+    getNumOverlayValues(overlayId: number): number;
+    getNumHairColors(): number;
+    getNumMakeupColors(): number;
+}
+export declare class RageMPPlatformBridge extends IClientPlatformBridge {
+    private playerReady;
+    constructor();
+    getHashKey(value: string): number;
+    getLocalPlayerPed(): number;
+    getEntityCoords(entity: number): CoreVector3;
+    getWorldPositionOfEntityBone(entity: number, bone: number): CoreVector3;
+    getGameplayCamCoords(): CoreVector3;
+    worldToScreen(position: CoreVector3): {
+        onScreen: boolean;
+        x: number;
+        y: number;
+    };
+    isModelInCdimage(hash: number): boolean;
+    isModelValid(hash: number): boolean;
+    isModelAVehicle(hash: number): boolean;
+    isModelAPed(hash: number): boolean;
+    requestModel(hash: number): void;
+    hasModelLoaded(hash: number): boolean;
+    setModelAsNoLongerNeeded(hash: number): void;
+    requestAnimDict(dict: string): void;
+    hasAnimDictLoaded(dict: string): boolean;
+    removeAnimDict(dict: string): void;
+    doesEntityExist(entity: number): boolean;
+    setEntityAsMissionEntity(entity: number, mission: boolean, scriptHostObject: boolean): void;
+    setBlockingOfNonTemporaryEvents(ped: number, toggle: boolean): void;
+    setPedRelationshipGroupHash(ped: number, groupHash: number): void;
+    createPed(pedType: number, modelHash: number, position: CoreVector3, heading: number, networked: boolean, scriptHostPed: boolean): number;
+    deletePed(ped: number): void;
+    createObject(modelHash: number, position: CoreVector3, networked: boolean, dynamic: boolean, _placeOnGround: boolean): number;
+    deleteEntity(entity: number): void;
+    attachEntityToEntity(entity: number, target: number, boneIndex: number, offset: CoreVector3, rotation: CoreVector3): void;
+    getPedBoneIndex(ped: number, bone: number): number;
+    taskPlayAnim(ped: number, dict: string, anim: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flags: number, playbackRate: number): void;
+    stopAnimTask(ped: number, dict: string, anim: string, blendOutSpeed: number): void;
+    clearPedTasks(ped: number): void;
+    clearPedTasksImmediately(ped: number): void;
+    freezeEntityPosition(entity: number, toggle: boolean): void;
+    setEntityInvincible(entity: number, toggle: boolean): void;
+    giveWeaponToPed(ped: number, weaponHash: number, ammoCount: number, _hidden: boolean, forceInHand: boolean): void;
+    removeAllPedWeapons(ped: number, _includeCurrentWeapon: boolean): void;
+    getClosestPed(position: CoreVector3, radius: number): number | null;
+    getNearbyPeds(position: CoreVector3, radius: number, excludeEntity?: number): number[];
+    taskLookAtEntity(ped: number, entity: number, duration: number): void;
+    taskLookAtCoord(ped: number, position: CoreVector3, duration: number): void;
+    taskGoStraightToCoord(ped: number, position: CoreVector3, speed: number): void;
+    setPedCombatAttributes(): void;
+    createVehicle(modelHash: number, position: CoreVector3, heading: number, networked: boolean, scriptHostVehicle: boolean): number;
+    deleteVehicle(vehicle: number): void;
+    setVehicleOnGroundProperly(vehicle: number): void;
+    getVehicleColours(vehicle: number): [number, number];
+    setVehicleColours(vehicle: number, primary: number, secondary: number): void;
+    setVehicleNumberPlateText(vehicle: number, plateText: string): void;
+    taskWarpPedIntoVehicle(ped: number, vehicle: number, seatIndex: number): void;
+    taskLeaveVehicle(ped: number, vehicle: number, flags: number): void;
+    getClosestVehicle(position: CoreVector3, radius: number): number | null;
+    isPedInAnyVehicle(ped: number): boolean;
+    getVehiclePedIsIn(ped: number, lastVehicle: boolean): number | null;
+    getPedInVehicleSeat(vehicle: number, seatIndex: number): number | null;
+    getEntitySpeed(entity: number): number;
+    networkGetNetworkIdFromEntity(entity: number): number;
+    networkDoesEntityExistWithNetworkId(networkId: number): boolean;
+    networkGetEntityFromNetworkId(networkId: number): number;
+    getEntityHeading(entity: number): number;
+    getEntityModel(entity: number): number;
+    setVehicleModKit(vehicle: number, kit: number): void;
+    setVehicleMod(vehicle: number, modType: number, modIndex: number, customTires: boolean): void;
+    toggleVehicleMod(vehicle: number, modType: number, toggle: boolean): void;
+    setVehicleWheelType(vehicle: number, wheelType: number): void;
+    setVehicleWindowTint(vehicle: number, tint: number): void;
+    setVehicleLivery(vehicle: number, livery: number): void;
+    setVehicleNumberPlateTextIndex(vehicle: number, index: number): void;
+    setVehicleNeonLightEnabled(vehicle: number, index: number, enabled: boolean): void;
+    setVehicleNeonLightsColour(vehicle: number, r: number, g: number, b: number): void;
+    setVehicleExtra(vehicle: number, extraId: number, disable: boolean): void;
+    getVehicleExtraColours(vehicle: number): [number, number];
+    setVehicleExtraColours(vehicle: number, pearl: number, wheel: number): void;
+    setVehicleFixed(vehicle: number): void;
+    setVehicleDeformationFixed(vehicle: number): void;
+    setVehicleUndriveable(vehicle: number, toggle: boolean): void;
+    setVehicleEngineOn(vehicle: number, value: boolean, instantly: boolean, disableAutoStart: boolean): void;
+    setVehicleEngineHealth(vehicle: number, health: number): void;
+    setVehiclePetrolTankHealth(vehicle: number, health: number): void;
+    setVehicleFuelLevel(_vehicle: number, _level: number): void;
+    getVehicleFuelLevel(_vehicle: number): number;
+    setVehicleDoorsLocked(vehicle: number, doorLockStatus: number): void;
+    setEntityHeading(entity: number, heading: number): void;
+    setEntityCoords(entity: number, position: CoreVector3): void;
+    setEntityCoordsNoOffset(entity: number, position: CoreVector3): void;
+    setEntityHealth(entity: number, health: number): void;
+    getEntityMaxHealth(entity: number): number;
+    setPedArmour(ped: number, armour: number): void;
+    networkIsSessionStarted(): boolean;
+    isScreenFadedOut(): boolean;
+    isScreenFadingOut(): boolean;
+    doScreenFadeOut(ms: number): void;
+    isScreenFadedIn(): boolean;
+    isScreenFadingIn(): boolean;
+    doScreenFadeIn(ms: number): void;
+    networkResurrectLocalPlayer(position: CoreVector3, heading: number): void;
+    playerId(): number;
+    setPlayerModel(_playerId: number, modelHash: number): void;
+    requestCollisionAtCoord(position: CoreVector3): void;
+    shutdownLoadingScreen(): void;
+    shutdownLoadingScreenNui(): void;
+    hasCollisionLoadedAroundEntity(_entity: number): boolean;
+    resetEntityAlpha(entity: number): void;
+    setEntityAlpha(entity: number, alphaLevel: number): void;
+    setEntityVisible(entity: number, toggle: boolean): void;
+    setEntityCollision(entity: number, toggle: boolean): void;
+    getVehicleNumberPlateText(vehicle: number): string;
+    requestScriptAudioBank(_bank: string, _networked: boolean): boolean;
+}