@open-core/framework 0.1.0-alpha.1

package/dist/client/system/processors/gameEvent.processor.d.ts

@@ -0,0 +1,10 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+interface GameEventMetadata {
+    eventName: string;
+    autoParse: boolean;
+}
+export declare class GameEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: GameEventMetadata): void;
+}
+export {};

package/dist/client/system/processors/gameEvent.processor.js

@@ -0,0 +1,58 @@
+"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.GameEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const game_events_1 = require("../../types/game-events");
+const clientGameEvent = logger_1.coreLogger.child('GameEvent', logger_1.LogDomain.CLIENT);
+// Map of event names to their parser functions
+const parserMap = {
+    CEventNetworkEntityDamage: game_events_1.GameEventParsers.parseEntityDamage,
+    CEventNetworkPlayerEnteredVehicle: game_events_1.GameEventParsers.parsePlayerEnteredVehicle,
+    CEventNetworkPlayerLeftVehicle: game_events_1.GameEventParsers.parsePlayerLeftVehicle,
+    CEventShockingSeenPedKilled: game_events_1.GameEventParsers.parseSeenPedKilled,
+    CEventNetworkVehicleUndrivable: game_events_1.GameEventParsers.parseVehicleUndrivable,
+    CEventGunShot: game_events_1.GameEventParsers.parseGunShot,
+};
+let GameEventProcessor = class GameEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.GAME_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const { eventName, autoParse } = metadata;
+        on('gameEventTriggered', async (name, args) => {
+            if (name !== eventName)
+                return;
+            try {
+                // Auto-parse if enabled and parser exists
+                if (autoParse && parserMap[eventName]) {
+                    const parsed = parserMap[eventName](args);
+                    await handler(parsed);
+                }
+                else {
+                    await handler(args);
+                }
+            }
+            catch (error) {
+                clientGameEvent.error(`Game event handler error`, {
+                    event: eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientGameEvent.debug(`Registered game event: ${eventName} -> ${handlerName}`);
+    }
+};
+exports.GameEventProcessor = GameEventProcessor;
+exports.GameEventProcessor = GameEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], GameEventProcessor);

package/dist/client/system/processors/interval.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class IntervalProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        interval: number;
+    }): void;
+}

package/dist/client/system/processors/interval.processor.js

@@ -0,0 +1,43 @@
+"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.IntervalProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientInterval = logger_1.coreLogger.child('Interval', logger_1.LogDomain.CLIENT);
+let IntervalProcessor = class IntervalProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.INTERVAL;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        let lastRun = 0;
+        setTick(async () => {
+            const now = GetGameTimer();
+            if (now - lastRun < metadata.interval)
+                return;
+            lastRun = now;
+            try {
+                await handler();
+            }
+            catch (error) {
+                clientInterval.error(`Interval handler error`, {
+                    handler: handlerName,
+                    interval: metadata.interval,
+                }, error);
+            }
+        });
+        clientInterval.debug(`Registered: ${handlerName} (every ${metadata.interval}ms)`);
+    }
+};
+exports.IntervalProcessor = IntervalProcessor;
+exports.IntervalProcessor = IntervalProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], IntervalProcessor);

package/dist/client/system/processors/key.processor.d.ts

@@ -0,0 +1,8 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class KeyMappingProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        key: string;
+        description: string;
+    }): void;
+}

package/dist/client/system/processors/key.processor.js

@@ -0,0 +1,27 @@
+"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.KeyMappingProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+let KeyMappingProcessor = class KeyMappingProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.KEY;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const commandName = `+${methodName}`;
+        RegisterCommand(commandName, handler, false);
+        RegisterKeyMapping(commandName, metadata.description, 'keyboard', metadata.key);
+        RegisterCommand(`-${methodName}`, () => { }, false);
+    }
+};
+exports.KeyMappingProcessor = KeyMappingProcessor;
+exports.KeyMappingProcessor = KeyMappingProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], KeyMappingProcessor);

package/dist/client/system/processors/localEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class LocalEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/client/system/processors/localEvent.processor.js

@@ -0,0 +1,38 @@
+"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.LocalEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientLocalEvent = logger_1.coreLogger.child('LocalEvent', logger_1.LogDomain.CLIENT);
+let LocalEventProcessor = class LocalEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.LOCAL_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        on(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientLocalEvent.error(`Handler error in local event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientLocalEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.LocalEventProcessor = LocalEventProcessor;
+exports.LocalEventProcessor = LocalEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], LocalEventProcessor);

package/dist/client/system/processors/netEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class ClientNetEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/client/system/processors/netEvent.processor.js

@@ -0,0 +1,38 @@
+"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.ClientNetEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientNetEvent = logger_1.coreLogger.child('NetEvent', logger_1.LogDomain.CLIENT);
+let ClientNetEventProcessor = class ClientNetEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.NET_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        onNet(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientNetEvent.error(`Handler error in event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientNetEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.ClientNetEventProcessor = ClientNetEventProcessor;
+exports.ClientNetEventProcessor = ClientNetEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], ClientNetEventProcessor);

package/dist/client/system/processors/nui.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class NuiProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/client/system/processors/nui.processor.js

@@ -0,0 +1,40 @@
+"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.NuiProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+let NuiProcessor = class NuiProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.NUI;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        RegisterNuiCallbackType(metadata.eventName);
+        on(`__cfx_nui:${metadata.eventName}`, async (data, cb) => {
+            try {
+                await handler(data);
+                cb({ ok: true });
+            }
+            catch (error) {
+                logger_1.loggers.nui.error(`NUI callback error`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+                cb({ ok: false, error: String(error) });
+            }
+        });
+        logger_1.loggers.nui.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.NuiProcessor = NuiProcessor;
+exports.NuiProcessor = NuiProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], NuiProcessor);

package/dist/client/system/processors/resourceLifecycle.processor.d.ts

@@ -0,0 +1,9 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class ResourceStartProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string): void;
+}
+export declare class ResourceStopProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string): void;
+}

package/dist/client/system/processors/resourceLifecycle.processor.js

@@ -0,0 +1,69 @@
+"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.ResourceStopProcessor = exports.ResourceStartProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientLifecycle = logger_1.coreLogger.child('Lifecycle', logger_1.LogDomain.CLIENT);
+let ResourceStartProcessor = class ResourceStartProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.RESOURCE_START;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const currentResource = GetCurrentResourceName();
+        on('onClientResourceStart', async (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            try {
+                await handler(resourceName);
+            }
+            catch (error) {
+                clientLifecycle.error(`Resource start handler error`, {
+                    handler: handlerName,
+                    resource: resourceName,
+                }, error);
+            }
+        });
+        clientLifecycle.debug(`Registered resource start handler: ${handlerName}`);
+    }
+};
+exports.ResourceStartProcessor = ResourceStartProcessor;
+exports.ResourceStartProcessor = ResourceStartProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], ResourceStartProcessor);
+let ResourceStopProcessor = class ResourceStopProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.RESOURCE_STOP;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const currentResource = GetCurrentResourceName();
+        on('onClientResourceStop', async (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            try {
+                await handler(resourceName);
+            }
+            catch (error) {
+                clientLifecycle.error(`Resource stop handler error`, {
+                    handler: handlerName,
+                    resource: resourceName,
+                }, error);
+            }
+        });
+        clientLifecycle.debug(`Registered resource stop handler: ${handlerName}`);
+    }
+};
+exports.ResourceStopProcessor = ResourceStopProcessor;
+exports.ResourceStopProcessor = ResourceStopProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], ResourceStopProcessor);

package/dist/client/system/processors/tick.processor.d.ts

@@ -0,0 +1,5 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class TickProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string): void;
+}

package/dist/client/system/processors/tick.processor.js

@@ -0,0 +1,37 @@
+"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.TickProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientTick = logger_1.coreLogger.child('Tick', logger_1.LogDomain.CLIENT);
+let TickProcessor = class TickProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.TICK;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        setTick(async () => {
+            try {
+                await handler();
+            }
+            catch (error) {
+                clientTick.error(`Tick handler error`, {
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientTick.debug(`Registered: ${handlerName}`);
+    }
+};
+exports.TickProcessor = TickProcessor;
+exports.TickProcessor = TickProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], TickProcessor);

package/dist/client/system/processors.register.d.ts

@@ -0,0 +1 @@
+export declare function registerSystemClient(): void;

package/dist/client/system/processors.register.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSystemClient = registerSystemClient;
+const client_container_1 = require("../client-container");
+const key_processor_1 = require("./processors/key.processor");
+const tick_processor_1 = require("./processors/tick.processor");
+const nui_processor_1 = require("./processors/nui.processor");
+const netEvent_processor_1 = require("./processors/netEvent.processor");
+const localEvent_processor_1 = require("./processors/localEvent.processor");
+const interval_processor_1 = require("./processors/interval.processor");
+const export_processor_1 = require("./processors/export.processor");
+const resourceLifecycle_processor_1 = require("./processors/resourceLifecycle.processor");
+const gameEvent_processor_1 = require("./processors/gameEvent.processor");
+function registerSystemClient() {
+    // Core processors
+    client_container_1.di.register('DecoratorProcessor', { useClass: key_processor_1.KeyMappingProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: tick_processor_1.TickProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: nui_processor_1.NuiProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: netEvent_processor_1.ClientNetEventProcessor });
+    // New processors
+    client_container_1.di.register('DecoratorProcessor', { useClass: localEvent_processor_1.LocalEventProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: interval_processor_1.IntervalProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: export_processor_1.ClientExportProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: resourceLifecycle_processor_1.ResourceStartProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: resourceLifecycle_processor_1.ResourceStopProcessor });
+    client_container_1.di.register('DecoratorProcessor', { useClass: gameEvent_processor_1.GameEventProcessor });
+}

package/dist/client/types/game-events.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Game Events - Native GTA V internal events captured by FiveM
+ *
+ * Documentation: https://docs.fivem.net/docs/game-references/game-events/
+ *
+ * These are low-level events from the RAGE engine. The arguments are
+ * passed as arrays from the native layer.
+ */
+export type GameEventName = 'CEventNetworkEntityDamage' | 'CEventNetworkPlayerEnteredVehicle' | 'CEventNetworkPlayerLeftVehicle' | 'CEventNetworkVehicleUndrivable' | 'CEventNetworkPlayerSpawn' | 'CEventNetworkPlayerCollectedPickup' | 'CEventNetworkPlayerCollectedAmbientPickup' | 'CEventShockingSeenPedKilled' | 'CEventShockingWeaponThreat' | 'CEventShockingGunshotFired' | 'CEventShockingExplosion' | 'CEventGunShot' | 'CEventGunShotWhizzedBy' | 'CEventExplosionHeard' | 'CEventShockingCarCrash' | 'CEventShockingBicycleCrash' | 'CEventShockingSeenCarStolen' | (string & {});
+/**
+ * CEventNetworkEntityDamage
+ * Fired when any networked entity takes damage
+ */
+export interface EntityDamageEvent {
+    /** Entity that was damaged */
+    victim: number;
+    /** Entity that caused the damage (0 if none) */
+    attacker: number;
+    /** Unknown parameter */
+    arg2: number;
+    /** Unknown parameter */
+    arg3: number;
+    /** Unknown parameter */
+    arg4: number;
+    /** Whether the victim died from this damage */
+    victimDied: boolean;
+    /** Weapon hash used */
+    weaponHash: number;
+    /** Unknown parameter */
+    arg7: number;
+    /** Unknown parameter */
+    arg8: number;
+    /** Unknown parameter - possibly damage amount related */
+    arg9: number;
+}
+/**
+ * CEventNetworkPlayerEnteredVehicle
+ * Fired when a player enters a vehicle
+ */
+export interface PlayerEnteredVehicleEvent {
+    /** Player that entered */
+    player: number;
+    /** Vehicle entered */
+    vehicle: number;
+}
+/**
+ * CEventNetworkPlayerLeftVehicle
+ * Fired when a player leaves a vehicle
+ */
+export interface PlayerLeftVehicleEvent {
+    /** Player that left */
+    player: number;
+    /** Vehicle left */
+    vehicle: number;
+}
+/**
+ * CEventShockingSeenPedKilled
+ * Fired when a ped witnesses another ped being killed
+ */
+export interface SeenPedKilledEvent {
+    /** Ped that witnessed the death */
+    witness: number;
+    /** Ped that was killed */
+    victim: number;
+}
+/**
+ * CEventGunShot
+ * Fired when a weapon is fired
+ */
+export interface GunShotEvent {
+    /** Entity that fired */
+    shooter: number;
+    /** Target coordinates */
+    coords: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/**
+ * CEventNetworkVehicleUndrivable
+ * Fired when a vehicle becomes undrivable (destroyed)
+ */
+export interface VehicleUndrivableEvent {
+    /** Vehicle that became undrivable */
+    vehicle: number;
+    /** Entity responsible (if any) */
+    attacker: number;
+    /** Weapon hash that caused it */
+    weaponHash: number;
+}
+export declare const GameEventParsers: {
+    /**
+     * Parse CEventNetworkEntityDamage arguments
+     */
+    parseEntityDamage(args: number[]): EntityDamageEvent;
+    /**
+     * Parse CEventNetworkPlayerEnteredVehicle arguments
+     */
+    parsePlayerEnteredVehicle(args: number[]): PlayerEnteredVehicleEvent;
+    /**
+     * Parse CEventNetworkPlayerLeftVehicle arguments
+     */
+    parsePlayerLeftVehicle(args: number[]): PlayerLeftVehicleEvent;
+    /**
+     * Parse CEventShockingSeenPedKilled arguments
+     */
+    parseSeenPedKilled(args: number[]): SeenPedKilledEvent;
+    /**
+     * Parse CEventNetworkVehicleUndrivable arguments
+     */
+    parseVehicleUndrivable(args: number[]): VehicleUndrivableEvent;
+    /**
+     * Parse CEventGunShot arguments
+     */
+    parseGunShot(args: number[]): GunShotEvent;
+};
+export interface GameEventMap {
+    CEventNetworkEntityDamage: EntityDamageEvent;
+    CEventNetworkPlayerEnteredVehicle: PlayerEnteredVehicleEvent;
+    CEventNetworkPlayerLeftVehicle: PlayerLeftVehicleEvent;
+    CEventShockingSeenPedKilled: SeenPedKilledEvent;
+    CEventNetworkVehicleUndrivable: VehicleUndrivableEvent;
+    CEventGunShot: GunShotEvent;
+    [key: string]: unknown;
+}