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

package/dist/adapters/contracts/transport/rpc.api.js

@@ -0,0 +1,20 @@
+/**
+ * Remote Procedure Call API.
+ *
+ * @remarks
+ * `RpcAPI` defines the contract for request/response style events.
+ *
+ * Direction depends on runtime:
+ * - Server runtime:
+ *   - `on()` registers handlers callable by clients.
+ *   - `call()/notify()` typically invokes handlers on clients (using {@link RpcTarget}).
+ * - Client runtime:
+ *   - `on()` registers handlers callable by server.
+ *   - `call()/notify()` typically invokes handlers on server.
+ *
+ * Transport implementations decide whether this is remote (network) or local (in-process):
+ * - FiveM transports: remote client<->server.
+ * - Node transports: often in-process (single runtime) and may ignore {@link RpcTarget}.
+ */
+export class RpcAPI {
+}

package/dist/adapters/contracts/types/identifier.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Generic player identifier structure.
+ *
+ * @remarks
+ * Platform-agnostic representation of player identifiers.
+ * Different platforms use different identifier systems:
+ * - FiveM: steam, license, discord, fivem, ip
+ * - RageMP: socialclub, ip
+ * - alt:V: socialclub, hwid, ip
+ */
+export interface PlayerIdentifier {
+    /**
+     * Identifier type.
+     * @example 'steam', 'license', 'discord', 'socialclub', 'hwid'
+     */
+    type: string;
+    /**
+     * Raw identifier value (without the type prefix).
+     * @example '110000100000001' (steam ID)
+     */
+    value: string;
+    /**
+     * Full identifier string as provided by the platform.
+     * @example 'steam:110000100000001'
+     */
+    raw: string;
+}
+/**
+ * Well-known identifier types across platforms.
+ */
+export declare const IdentifierTypes: {
+    readonly STEAM: "steam";
+    readonly IP: "ip";
+    readonly LICENSE: "license";
+    readonly LICENSE2: "license2";
+    readonly DISCORD: "discord";
+    readonly FIVEM: "fivem";
+    readonly XBL: "xbl";
+    readonly LIVE: "live";
+    readonly SOCIAL_CLUB: "socialclub";
+    readonly HWID: "hwid";
+    readonly ROCKSTAR: "rockstar";
+};
+export type IdentifierType = (typeof IdentifierTypes)[keyof typeof IdentifierTypes];
+/**
+ * Parse a raw identifier string into a PlayerIdentifier.
+ *
+ * @param raw - Raw identifier string (e.g., 'steam:110000100000001')
+ * @returns Parsed identifier or null if invalid format
+ */
+export declare function parseIdentifier(raw: string): PlayerIdentifier | null;
+/**
+ * Create a raw identifier string from type and value.
+ *
+ * @param type - Identifier type
+ * @param value - Identifier value
+ * @returns Raw identifier string
+ */
+export declare function createIdentifier(type: string, value: string): string;
+/**
+ * Find an identifier by type from a list.
+ *
+ * @param identifiers - List of identifiers
+ * @param type - Type to find
+ * @returns The identifier or undefined
+ */
+export declare function findIdentifierByType(identifiers: PlayerIdentifier[], type: string): PlayerIdentifier | undefined;

package/dist/adapters/contracts/types/identifier.js

@@ -0,0 +1,58 @@
+/**
+ * Well-known identifier types across platforms.
+ */
+export const IdentifierTypes = {
+    // Common across multiple platforms
+    STEAM: 'steam',
+    IP: 'ip',
+    // FiveM specific
+    LICENSE: 'license',
+    LICENSE2: 'license2',
+    DISCORD: 'discord',
+    FIVEM: 'fivem',
+    XBL: 'xbl',
+    LIVE: 'live',
+    // RageMP / alt:V specific
+    SOCIAL_CLUB: 'socialclub',
+    HWID: 'hwid',
+    // RedM specific
+    ROCKSTAR: 'rockstar',
+};
+/**
+ * Parse a raw identifier string into a PlayerIdentifier.
+ *
+ * @param raw - Raw identifier string (e.g., 'steam:110000100000001')
+ * @returns Parsed identifier or null if invalid format
+ */
+export function parseIdentifier(raw) {
+    const colonIndex = raw.indexOf(':');
+    if (colonIndex === -1) {
+        return null;
+    }
+    const type = raw.substring(0, colonIndex);
+    const value = raw.substring(colonIndex + 1);
+    if (!type || !value) {
+        return null;
+    }
+    return { type, value, raw };
+}
+/**
+ * Create a raw identifier string from type and value.
+ *
+ * @param type - Identifier type
+ * @param value - Identifier value
+ * @returns Raw identifier string
+ */
+export function createIdentifier(type, value) {
+    return `${type}:${value}`;
+}
+/**
+ * Find an identifier by type from a list.
+ *
+ * @param identifiers - List of identifiers
+ * @param type - Type to find
+ * @returns The identifier or undefined
+ */
+export function findIdentifierByType(identifiers, type) {
+    return identifiers.find((id) => id.type === type);
+}

package/dist/adapters/contracts/types/index.d.ts

@@ -0,0 +1 @@
+export * from './identifier';

package/dist/adapters/contracts/types/index.js

@@ -0,0 +1 @@
+export * from './identifier';

package/dist/adapters/fivem/fivem-capabilities.d.ts

@@ -0,0 +1,18 @@
+import { IPlatformCapabilities } from '../contracts/IPlatformCapabilities';
+/**
+ * FiveM platform capabilities implementation.
+ */
+export declare class FiveMCapabilities extends IPlatformCapabilities {
+    readonly platformName = "fivem";
+    readonly displayName = "FiveM";
+    readonly supportsRoutingBuckets = true;
+    readonly supportsStateBags = true;
+    readonly supportsVoiceChat = true;
+    readonly supportsServerEntities = true;
+    readonly identifierTypes: readonly ["steam", "license", "license2", "discord", "fivem", "xbl", "live", "ip"];
+    readonly maxPlayers = 1024;
+    private readonly supportedFeatures;
+    private readonly config;
+    isFeatureSupported(feature: string): boolean;
+    getConfig<T = unknown>(key: string): T | undefined;
+}

package/dist/adapters/fivem/fivem-capabilities.js

@@ -0,0 +1,61 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IPlatformCapabilities, PlatformFeatures } from '../contracts/IPlatformCapabilities';
+import { IdentifierTypes } from '../contracts/types/identifier';
+/**
+ * FiveM platform capabilities implementation.
+ */
+let FiveMCapabilities = class FiveMCapabilities extends IPlatformCapabilities {
+    platformName = 'fivem';
+    displayName = 'FiveM';
+    supportsRoutingBuckets = true;
+    supportsStateBags = true;
+    supportsVoiceChat = true;
+    supportsServerEntities = true;
+    identifierTypes = [
+        IdentifierTypes.STEAM,
+        IdentifierTypes.LICENSE,
+        IdentifierTypes.LICENSE2,
+        IdentifierTypes.DISCORD,
+        IdentifierTypes.FIVEM,
+        IdentifierTypes.XBL,
+        IdentifierTypes.LIVE,
+        IdentifierTypes.IP,
+    ];
+    maxPlayers = 1024;
+    supportedFeatures = new Set([
+        PlatformFeatures.ROUTING_BUCKETS,
+        PlatformFeatures.STATE_BAGS,
+        PlatformFeatures.VOICE_CHAT,
+        PlatformFeatures.SERVER_ENTITIES,
+        PlatformFeatures.VEHICLE_MODS,
+        PlatformFeatures.PED_APPEARANCE,
+        PlatformFeatures.WEAPON_COMPONENTS,
+        PlatformFeatures.BLIPS,
+        PlatformFeatures.MARKERS,
+        PlatformFeatures.TEXT_LABELS,
+        PlatformFeatures.CHECKPOINTS,
+        PlatformFeatures.COLSHAPES,
+    ]);
+    config = {
+        defaultRoutingBucket: 0,
+        maxRoutingBuckets: 63,
+        tickRate: 64,
+        syncRate: 10,
+    };
+    isFeatureSupported(feature) {
+        return this.supportedFeatures.has(feature);
+    }
+    getConfig(key) {
+        return this.config[key];
+    }
+};
+FiveMCapabilities = __decorate([
+    injectable()
+], FiveMCapabilities);
+export { FiveMCapabilities };

package/dist/adapters/fivem/fivem-engine-events.d.ts

@@ -0,0 +1,5 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+export declare class FiveMEngineEvents extends IEngineEvents {
+    on(eventName: string, handler?: (...args: any[]) => void): void;
+    emit(eventName: string, ...args: any[]): void;
+}

package/dist/adapters/fivem/fivem-engine-events.js

@@ -0,0 +1,24 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+export class FiveMEngineEvents extends IEngineEvents {
+    on(eventName, handler) {
+        if (!handler)
+            return;
+        on(eventName, (...args) => {
+            if (eventName === 'playerJoining') {
+                const clientId = Number(source);
+                const license = GetPlayerIdentifier(clientId.toString(), 0) ?? undefined;
+                handler(clientId, { license });
+                return;
+            }
+            if (eventName === 'playerDropped') {
+                const clientId = Number(source);
+                handler(clientId);
+                return;
+            }
+            handler(...args);
+        });
+    }
+    emit(eventName, ...args) {
+        emit(eventName, ...args);
+    }
+}

package/dist/adapters/fivem/fivem-entity-server.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from '../../kernel/utils/vector3';
+import { type EntityStateBag, IEntityServer, type SetPositionOptions } from '../contracts/server/IEntityServer';
+/**
+ * FiveM implementation of server-side entity operations.
+ */
+export declare class FiveMEntityServer extends IEntityServer {
+    doesExist(handle: number): boolean;
+    getCoords(handle: number): Vector3;
+    setPosition(handle: number, position: Vector3, options?: SetPositionOptions): void;
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle: number, x: number, y: number, z: number, alive?: boolean, deadFlag?: boolean, ragdollFlag?: boolean, clearArea?: boolean): void;
+    getHeading(handle: number): number;
+    setHeading(handle: number, heading: number): void;
+    getModel(handle: number): number;
+    delete(handle: number): void;
+    setOrphanMode(handle: number, mode: number): void;
+    setRoutingBucket(handle: number, bucket: number): void;
+    getRoutingBucket(handle: number): number;
+    getStateBag(handle: number): EntityStateBag;
+    getHealth(handle: number): number;
+    setHealth(handle: number, health: number): void;
+    getArmor(handle: number): number;
+    setArmor(handle: number, armor: number): void;
+}

package/dist/adapters/fivem/fivem-entity-server.js

@@ -0,0 +1,87 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IEntityServer, } from '../contracts/server/IEntityServer';
+/**
+ * FiveM implementation of server-side entity operations.
+ */
+let FiveMEntityServer = class FiveMEntityServer extends IEntityServer {
+    doesExist(handle) {
+        return DoesEntityExist(handle);
+    }
+    getCoords(handle) {
+        const coords = GetEntityCoords(handle);
+        return { x: coords[0], y: coords[1], z: coords[2] };
+    }
+    setPosition(handle, position, options) {
+        const keepAlive = options?.keepAlive ?? false;
+        const clearArea = options?.clearArea ?? true;
+        const platformOpts = options?.platformOptions ?? {};
+        // Extract FiveM-specific flags from platformOptions
+        const deadFlag = platformOpts.deadFlag ?? false;
+        const ragdollFlag = platformOpts.ragdollFlag ?? false;
+        SetEntityCoords(handle, position.x, position.y, position.z, keepAlive, deadFlag, ragdollFlag, clearArea);
+    }
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle, x, y, z, alive = false, deadFlag = false, ragdollFlag = false, clearArea = true) {
+        SetEntityCoords(handle, x, y, z, alive, deadFlag, ragdollFlag, clearArea);
+    }
+    getHeading(handle) {
+        return GetEntityHeading(handle);
+    }
+    setHeading(handle, heading) {
+        SetEntityHeading(handle, heading);
+    }
+    getModel(handle) {
+        return GetEntityModel(handle);
+    }
+    delete(handle) {
+        DeleteEntity(handle);
+    }
+    setOrphanMode(handle, mode) {
+        SetEntityOrphanMode(handle, mode);
+    }
+    setRoutingBucket(handle, bucket) {
+        SetEntityRoutingBucket(handle, bucket);
+    }
+    getRoutingBucket(handle) {
+        return GetEntityRoutingBucket(handle);
+    }
+    getStateBag(handle) {
+        const stateBag = Entity(handle).state;
+        return {
+            set: (key, value, replicated = true) => {
+                stateBag.set(key, value, replicated);
+            },
+            get: (key) => {
+                return stateBag[key];
+            },
+        };
+    }
+    getHealth(handle) {
+        const stateBag = Entity(handle).state;
+        return stateBag.health ?? 200;
+    }
+    setHealth(handle, health) {
+        const stateBag = Entity(handle).state;
+        stateBag.set('health', health, true);
+    }
+    getArmor(handle) {
+        const stateBag = Entity(handle).state;
+        return stateBag.armor ?? 0;
+    }
+    setArmor(handle, armor) {
+        const stateBag = Entity(handle).state;
+        stateBag.set('armor', armor, true);
+    }
+};
+FiveMEntityServer = __decorate([
+    injectable()
+], FiveMEntityServer);
+export { FiveMEntityServer };

package/dist/adapters/fivem/fivem-exports.d.ts

@@ -0,0 +1,5 @@
+import { IExports } from '../contracts/IExports';
+export declare class FiveMExports extends IExports {
+    register(exportName: string, handler: (...args: any[]) => any): void;
+    getResource<T = any>(resourceName: string): T | undefined;
+}

package/dist/adapters/fivem/fivem-exports.js

@@ -0,0 +1,9 @@
+import { IExports } from '../contracts/IExports';
+export class FiveMExports extends IExports {
+    register(exportName, handler) {
+        exports(exportName, handler);
+    }
+    getResource(resourceName) {
+        return globalThis.exports?.[resourceName];
+    }
+}

package/dist/adapters/fivem/fivem-hasher.d.ts

@@ -0,0 +1,7 @@
+import { IHasher } from '../contracts/IHasher';
+/**
+ * FiveM implementation of hash utilities.
+ */
+export declare class FiveMHasher extends IHasher {
+    getHashKey(str: string): number;
+}

package/dist/adapters/fivem/fivem-hasher.js

@@ -0,0 +1,20 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IHasher } from '../contracts/IHasher';
+/**
+ * FiveM implementation of hash utilities.
+ */
+let FiveMHasher = class FiveMHasher extends IHasher {
+    getHashKey(str) {
+        return GetHashKey(str);
+    }
+};
+FiveMHasher = __decorate([
+    injectable()
+], FiveMHasher);
+export { FiveMHasher };

package/dist/adapters/fivem/fivem-net-transport.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/fivem/fivem-ped-appearance-client.d.ts

@@ -0,0 +1,34 @@
+import { HeadBlendData } from '../../kernel/shared';
+import { IPedAppearanceClient } from '../contracts/client/IPedAppearanceClient';
+/**
+ * FiveM implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * Wraps FiveM natives for ped appearance manipulation.
+ * All natives are client-side only.
+ */
+export declare class FiveMPedAppearanceClientAdapter extends IPedAppearanceClient {
+    setComponentVariation(ped: number, componentId: number, drawable: number, texture: number, palette: number): void;
+    setPropIndex(ped: number, propId: number, drawable: number, texture: number, attach: boolean): 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, index: 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, drawable: number): number;
+    getNumPropDrawableVariations(ped: number, propId: number): number;
+    getNumPropTextureVariations(ped: number, propId: number, drawable: number): number;
+    getNumOverlayValues(overlayId: number): number;
+    getNumHairColors(): number;
+    getNumMakeupColors(): number;
+}

package/dist/adapters/fivem/fivem-ped-appearance-client.js

@@ -0,0 +1,79 @@
+import { IPedAppearanceClient } from '../contracts/client/IPedAppearanceClient';
+/**
+ * FiveM implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * Wraps FiveM natives for ped appearance manipulation.
+ * All natives are client-side only.
+ */
+export class FiveMPedAppearanceClientAdapter extends IPedAppearanceClient {
+    setComponentVariation(ped, componentId, drawable, texture, palette) {
+        SetPedComponentVariation(ped, componentId, drawable, texture, palette);
+    }
+    setPropIndex(ped, propId, drawable, texture, attach) {
+        SetPedPropIndex(ped, propId, drawable, texture, attach);
+    }
+    clearProp(ped, propId) {
+        ClearPedProp(ped, propId);
+    }
+    setDefaultComponentVariation(ped) {
+        SetPedDefaultComponentVariation(ped);
+    }
+    setHeadBlendData(ped, data) {
+        SetPedHeadBlendData(ped, data.shapeFirst, data.shapeSecond, data.shapeThird ?? 0, data.skinFirst, data.skinSecond, data.skinThird ?? 0, data.shapeMix, data.skinMix, data.thirdMix ?? 0, false);
+    }
+    setFaceFeature(ped, index, scale) {
+        SetPedFaceFeature(ped, index, scale);
+    }
+    setHeadOverlay(ped, overlayId, index, opacity) {
+        SetPedHeadOverlay(ped, overlayId, index, opacity);
+    }
+    setHeadOverlayColor(ped, overlayId, colorType, colorId, secondColorId) {
+        SetPedHeadOverlayColor(ped, overlayId, colorType, colorId, secondColorId);
+    }
+    setHairColor(ped, colorId, highlightColorId) {
+        SetPedHairColor(ped, colorId, highlightColorId);
+    }
+    setEyeColor(ped, index) {
+        SetPedEyeColor(ped, index);
+    }
+    addDecoration(ped, collectionHash, overlayHash) {
+        AddPedDecorationFromHashes(ped, collectionHash, overlayHash);
+    }
+    clearDecorations(ped) {
+        ClearPedDecorations(ped);
+    }
+    getDrawableVariation(ped, componentId) {
+        return GetPedDrawableVariation(ped, componentId);
+    }
+    getTextureVariation(ped, componentId) {
+        return GetPedTextureVariation(ped, componentId);
+    }
+    getPropIndex(ped, propId) {
+        return GetPedPropIndex(ped, propId);
+    }
+    getPropTextureIndex(ped, propId) {
+        return GetPedPropTextureIndex(ped, propId);
+    }
+    getNumDrawableVariations(ped, componentId) {
+        return GetNumberOfPedDrawableVariations(ped, componentId);
+    }
+    getNumTextureVariations(ped, componentId, drawable) {
+        return GetNumberOfPedTextureVariations(ped, componentId, drawable);
+    }
+    getNumPropDrawableVariations(ped, propId) {
+        return GetNumberOfPedPropDrawableVariations(ped, propId);
+    }
+    getNumPropTextureVariations(ped, propId, drawable) {
+        return GetNumberOfPedPropTextureVariations(ped, propId, drawable);
+    }
+    getNumOverlayValues(overlayId) {
+        return GetNumHeadOverlayValues(overlayId);
+    }
+    getNumHairColors() {
+        return GetNumHairColors();
+    }
+    getNumMakeupColors() {
+        return GetNumMakeupColors();
+    }
+}

package/dist/adapters/fivem/fivem-ped-appearance-server.d.ts

@@ -0,0 +1,14 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * FiveM implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * Wraps FiveM natives for ped appearance manipulation on server-side.
+ * Server-side has limited appearance control - only components and props.
+ */
+export declare class FiveMPedAppearanceServerAdapter extends IPedAppearanceServer {
+    setComponentVariation(ped: number, componentId: number, drawable: number, texture: number, palette: number): void;
+    setPropIndex(ped: number, propId: number, drawable: number, texture: number, attach: boolean): void;
+    clearProp(ped: number, propId: number): void;
+    setDefaultComponentVariation(ped: number): void;
+}

package/dist/adapters/fivem/fivem-ped-appearance-server.js

@@ -0,0 +1,22 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * FiveM implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * Wraps FiveM natives for ped appearance manipulation on server-side.
+ * Server-side has limited appearance control - only components and props.
+ */
+export class FiveMPedAppearanceServerAdapter extends IPedAppearanceServer {
+    setComponentVariation(ped, componentId, drawable, texture, palette) {
+        SetPedComponentVariation(ped, componentId, drawable, texture, palette);
+    }
+    setPropIndex(ped, propId, drawable, texture, attach) {
+        SetPedPropIndex(ped, propId, drawable, texture, attach);
+    }
+    clearProp(ped, propId) {
+        ClearPedProp(ped, propId);
+    }
+    setDefaultComponentVariation(ped) {
+        SetPedDefaultComponentVariation(ped);
+    }
+}

package/dist/adapters/fivem/fivem-ped-server.d.ts

@@ -0,0 +1,9 @@
+import { IPedServer } from '../contracts/server/IPedServer';
+/** FiveM implementation of server-side ped operations. */
+export declare class FiveMPedServer extends IPedServer {
+    create(pedType: number, modelHash: number, x: number, y: number, z: number, heading: number, networked: boolean): number;
+    delete(handle: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+}

package/dist/adapters/fivem/fivem-ped-server.js

@@ -0,0 +1,30 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IPedServer } from '../contracts/server/IPedServer';
+/** FiveM implementation of server-side ped operations. */
+let FiveMPedServer = class FiveMPedServer extends IPedServer {
+    create(pedType, modelHash, x, y, z, heading, networked) {
+        return CreatePed(pedType, modelHash, x, y, z, heading, networked, true);
+    }
+    delete(handle) {
+        DeleteEntity(handle);
+    }
+    getNetworkIdFromEntity(handle) {
+        return NetworkGetNetworkIdFromEntity(handle);
+    }
+    getEntityFromNetworkId(networkId) {
+        return NetworkGetEntityFromNetworkId(networkId);
+    }
+    networkIdExists(networkId) {
+        return NetworkDoesEntityExistWithNetworkId(networkId);
+    }
+};
+FiveMPedServer = __decorate([
+    injectable()
+], FiveMPedServer);
+export { FiveMPedServer };

package/dist/adapters/fivem/fivem-platform.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformAdapter } from '../platform/platform-registry';
+/**
+ * FiveM platform adapter for automatic registration.
+ */
+export declare const FiveMPlatform: PlatformAdapter;