@nativewrappers/fivem 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dillon Skaggs 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+<h1 align="center">Monorepo for a FiveM server/client wrapper</h1>
+
+<p align="center">
+  <i>:fire: A Javascript/Typescript wrapper for the FiveM server natives :video_game:</i>
+  <br>
+  <br>
+  <a href="https://github.com/nativewrappers/fivem-server/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat" alt="License: MIT">
+  </a>
+  <a href="https://github.com/nativewrappers/fivem/commits/master">
+    <img src="https://img.shields.io/github/last-commit/nativewrappers/fivem.svg?style=flat" alt="Last commit">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://fivemjs-server.avarian.dev/">Documentation</a>
+  -
+  <a href="https://forum.fivem.net/t/fivem-js-v1-3-2-javascript-typescript-wrapper-now-with-menu-class-nativeui/268640">Forum</a>
+</p>
+
+This project is in no way affiliated with FiveM or the Cfx Collective.
+
+## Features
+- No runtime dependencies
+- Abstracts common used FiveM practices
+- Entity management through class objects (i.e. `Vehicle` and `Ped` entities)
+
+
+## Download & Install
+
+`pnpm add @nativewrappers/fivem-server`
+
+

package/lib/client/Audio.d.ts

@@ -0,0 +1,17 @@
+import { AudioFlag } from './enums';
+import type { BaseEntity } from './models/BaseEntity';
+import { Vector3 } from './utils';
+export declare abstract class Audio {
+    static playSoundAt(position: Vector3, sound: string, set?: string, generateSoundId?: boolean): number;
+    static playSoundFromEntity(entity: BaseEntity, sound: string, set?: string, generateSoundId?: boolean): number;
+    static playSoundFrontEnd(sound: string, set?: string, generateSoundId?: boolean): number;
+    static stopSound(soundId: number): void;
+    static releaseSound(soundId: number): void;
+    static hasSoundFinished(soundId: number): boolean;
+    static setAudioFlag(flag: string | AudioFlag, toggle: boolean): void;
+    static playSound(soundFile: string, soundSet: string): void;
+    static playMusic(musicFile: string): void;
+    static stopMusic(musicFile?: string): void;
+    protected static cachedMusicFile: string;
+    private static readonly audioFlags;
+}

package/lib/client/Audio.js

@@ -0,0 +1,92 @@
+export class Audio {
+    static playSoundAt(position, sound, set, generateSoundId = true) {
+        const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+        PlaySoundFromCoord(SOUND_ID, sound, position.x, position.y, position.z, set ?? '', false, 0, false);
+        return SOUND_ID;
+    }
+    static playSoundFromEntity(entity, sound, set, generateSoundId = true) {
+        const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+        PlaySoundFromEntity(SOUND_ID, sound, entity.Handle, set ?? '', false, 0);
+        return SOUND_ID;
+    }
+    static playSoundFrontEnd(sound, set, generateSoundId = true) {
+        const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+        PlaySoundFrontend(SOUND_ID, sound, set ?? '', false);
+        return SOUND_ID;
+    }
+    static stopSound(soundId) {
+        StopSound(soundId);
+    }
+    static releaseSound(soundId) {
+        ReleaseSoundId(soundId);
+    }
+    static hasSoundFinished(soundId) {
+        return HasSoundFinished(soundId);
+    }
+    static setAudioFlag(flag, toggle) {
+        if (typeof flag === 'string') {
+            SetAudioFlag(flag, toggle);
+        }
+        else {
+            SetAudioFlag(this.audioFlags[Number(flag)], toggle);
+        }
+    }
+    static playSound(soundFile, soundSet) {
+        this.releaseSound(this.playSoundFrontEnd(soundFile, soundSet));
+    }
+    static playMusic(musicFile) {
+        if (!this.cachedMusicFile) {
+            CancelMusicEvent(musicFile);
+        }
+        this.cachedMusicFile = musicFile;
+        TriggerMusicEvent(musicFile);
+    }
+    static stopMusic(musicFile) {
+        if (!musicFile) {
+            if (!this.cachedMusicFile) {
+                CancelMusicEvent(this.cachedMusicFile);
+                this.cachedMusicFile = '';
+            }
+        }
+        else {
+            CancelMusicEvent(musicFile ?? '');
+        }
+    }
+}
+Audio.audioFlags = [
+    'ActivateSwitchWheelAudio',
+    'AllowCutsceneOverScreenFade',
+    'AllowForceRadioAfterRetune',
+    'AllowPainAndAmbientSpeechToPlayDuringCutscene',
+    'AllowPlayerAIOnMission',
+    'AllowPoliceScannerWhenPlayerHasNoControl',
+    'AllowRadioDuringSwitch',
+    'AllowRadioOverScreenFade',
+    'AllowScoreAndRadio',
+    'AllowScriptedSpeechInSlowMo',
+    'AvoidMissionCompleteDelay',
+    'DisableAbortConversationForDeathAndInjury',
+    'DisableAbortConversationForRagdoll',
+    'DisableBarks',
+    'DisableFlightMusic',
+    'DisableReplayScriptStreamRecording',
+    'EnableHeadsetBeep',
+    'ForceConversationInterrupt',
+    'ForceSeamlessRadioSwitch',
+    'ForceSniperAudio',
+    'FrontendRadioDisabled',
+    'HoldMissionCompleteWhenPrepared',
+    'IsDirectorModeActive',
+    'IsPlayerOnMissionForSpeech',
+    'ListenerReverbDisabled',
+    'LoadMPData',
+    'MobileRadioInGame',
+    'OnlyAllowScriptTriggerPoliceScanner',
+    'PlayMenuMusic',
+    'PoliceScannerDisabled',
+    'ScriptedConvListenerMaySpeak',
+    'SpeechDucksScore',
+    'SuppressPlayerScubaBreathing',
+    'WantedMusicDisabled',
+    'WantedMusicOnMission',
+];

package/lib/client/Blip.d.ts

@@ -0,0 +1,39 @@
+import { Vector3 } from './utils';
+import { BlipColor, BlipSprite } from './enums';
+import { Player } from './models';
+import { EntityType } from './types/EntityType';
+export declare class Blip {
+    protected handle: number;
+    constructor(handle: number);
+    get Handle(): number;
+    get Position(): Vector3;
+    set Position(location: Vector3);
+    set Rotation(rotation: number);
+    set Scale(scale: number);
+    get Type(): number;
+    get Alpha(): number;
+    set Alpha(alpha: number);
+    set Priority(priority: number);
+    set NumberLabel(number: number);
+    get Color(): BlipColor;
+    set Color(color: BlipColor);
+    get Sprite(): BlipSprite;
+    set Sprite(sprite: BlipSprite);
+    set Display(display: number);
+    set Name(name: string);
+    setNameToPlayerName(player: Player): void;
+    get Entity(): EntityType | null;
+    set ShowHeadingIndicator(show: boolean);
+    set ShowRoute(show: boolean);
+    set IsFriendly(friendly: boolean);
+    set IsFriend(friend: boolean);
+    set IsCrew(crew: boolean);
+    get IsFlashing(): boolean;
+    set IsFlashing(flashing: boolean);
+    get IsOnMinimap(): boolean;
+    get IsShortRange(): boolean;
+    set IsShortRange(shortRange: boolean);
+    removeNumberLabel(): void;
+    delete(): void;
+    exists(): boolean;
+}

package/lib/client/Blip.js

@@ -0,0 +1,104 @@
+import { Vector3 } from './utils';
+import { Entity } from './models/Entity';
+export class Blip {
+    constructor(handle) {
+        this.handle = handle;
+    }
+    get Handle() {
+        return this.handle;
+    }
+    get Position() {
+        return Vector3.fromArray(GetBlipInfoIdCoord(this.handle));
+    }
+    set Position(location) {
+        SetBlipCoords(this.handle, location.x, location.y, location.z);
+    }
+    set Rotation(rotation) {
+        SetBlipRotation(this.handle, rotation);
+    }
+    set Scale(scale) {
+        SetBlipScale(this.handle, scale);
+    }
+    get Type() {
+        return GetBlipInfoIdType(this.handle);
+    }
+    get Alpha() {
+        return GetBlipAlpha(this.handle);
+    }
+    set Alpha(alpha) {
+        SetBlipAlpha(this.handle, alpha);
+    }
+    set Priority(priority) {
+        SetBlipPriority(this.handle, priority);
+    }
+    set NumberLabel(number) {
+        ShowNumberOnBlip(this.handle, number);
+    }
+    get Color() {
+        return GetBlipColour(this.handle);
+    }
+    set Color(color) {
+        SetBlipColour(this.handle, color);
+    }
+    get Sprite() {
+        return GetBlipSprite(this.handle);
+    }
+    set Sprite(sprite) {
+        SetBlipSprite(this.handle, sprite);
+    }
+    set Display(display) {
+        SetBlipDisplay(this.handle, display);
+    }
+    set Name(name) {
+        BeginTextCommandSetBlipName('STRING');
+        AddTextComponentSubstringPlayerName(name);
+        EndTextCommandSetBlipName(this.handle);
+    }
+    setNameToPlayerName(player) {
+        SetBlipNameToPlayerName(this.handle, player.Handle);
+    }
+    get Entity() {
+        return Entity.fromHandle(GetBlipInfoIdEntityIndex(this.handle));
+    }
+    set ShowHeadingIndicator(show) {
+        ShowHeadingIndicatorOnBlip(this.handle, show);
+    }
+    set ShowRoute(show) {
+        SetBlipRoute(this.handle, show);
+    }
+    set IsFriendly(friendly) {
+        SetBlipAsFriendly(this.handle, friendly);
+    }
+    set IsFriend(friend) {
+        SetBlipFriend(this.handle, friend);
+    }
+    set IsCrew(crew) {
+        SetBlipCrew(this.handle, crew);
+    }
+    get IsFlashing() {
+        return IsBlipFlashing(this.handle);
+    }
+    set IsFlashing(flashing) {
+        SetBlipFlashes(this.handle, flashing);
+    }
+    get IsOnMinimap() {
+        return IsBlipOnMinimap(this.handle);
+    }
+    get IsShortRange() {
+        return IsBlipShortRange(this.handle);
+    }
+    set IsShortRange(shortRange) {
+        SetBlipAsShortRange(this.handle, shortRange);
+    }
+    removeNumberLabel() {
+        HideNumberOnBlip(this.handle);
+    }
+    delete() {
+        if (this.exists()) {
+            RemoveBlip(this.handle);
+        }
+    }
+    exists() {
+        return DoesBlipExist(this.handle);
+    }
+}

package/lib/client/Camera.d.ts

@@ -0,0 +1,46 @@
+import { CameraShake } from './enums';
+import { PedBone } from './models';
+import { BaseEntity } from './models/BaseEntity';
+import { Vector3 } from './utils';
+export declare class Camera {
+    static readonly shakeNames: string[];
+    private handle;
+    constructor(handle: number);
+    get Handle(): number;
+    get IsActive(): boolean;
+    set IsActive(active: boolean);
+    get Position(): Vector3;
+    set Position(position: Vector3);
+    get Rotation(): Vector3;
+    set Rotation(rotation: Vector3);
+    /**
+     * Gets the direction the camera is facing. Same as ForwardVector
+     */
+    get Direction(): Vector3;
+    set Direction(direction: Vector3);
+    get ForwardVector(): Vector3;
+    get FieldOfView(): number;
+    set FieldOfView(fieldOfView: number);
+    get NearClip(): number;
+    set NearClip(nearClip: number);
+    get FarClip(): number;
+    set FarClip(farClip: number);
+    set NearDepthOfField(nearDepthOfField: number);
+    get FarDepthOfField(): number;
+    set FarDepthOfField(farDepthOfField: number);
+    set DepthOfFieldStrength(strength: number);
+    set MotionBlurStrength(strength: number);
+    shake(shakeType: CameraShake, amplitude: number): void;
+    stopShaking(): void;
+    get IsShaking(): boolean;
+    set ShakeAmplitude(amplitude: number);
+    playAnim(animName: string, animDict: string, position: Vector3, rotation: Vector3): Promise<void>;
+    pointAt(target: BaseEntity | PedBone | Vector3, offset?: Vector3): void;
+    stopPointing(): void;
+    interpTo(to: Camera, duration: number, easePosition: boolean, easeRotation: boolean): void;
+    get IsInterpolating(): boolean;
+    attachTo(object: BaseEntity | PedBone, offset: Vector3): void;
+    detach(): void;
+    delete(): void;
+    exists(): boolean;
+}

package/lib/client/Camera.js

@@ -0,0 +1,161 @@
+import { PedBone } from './models';
+import { BaseEntity } from './models/BaseEntity';
+import { Vector3 } from './utils';
+import { LoadAnimDict } from './utils/Animations';
+export class Camera {
+    constructor(handle) {
+        this.handle = handle;
+    }
+    get Handle() {
+        return this.handle;
+    }
+    get IsActive() {
+        return IsCamActive(this.handle);
+    }
+    set IsActive(active) {
+        SetCamActive(this.handle, active);
+    }
+    get Position() {
+        return Vector3.fromArray(GetCamCoord(this.handle));
+    }
+    set Position(position) {
+        SetCamCoord(this.handle, position.x, position.y, position.z);
+    }
+    get Rotation() {
+        return Vector3.fromArray(GetCamRot(this.handle, 2));
+    }
+    set Rotation(rotation) {
+        SetCamRot(this.handle, rotation.x, rotation.y, rotation.z, 2);
+    }
+    // public get Matrix() : Matrix {}
+    /**
+     * Gets the direction the camera is facing. Same as ForwardVector
+     */
+    get Direction() {
+        return this.ForwardVector;
+    }
+    set Direction(direction) {
+        const dir = direction.normalize;
+        const vec1 = new Vector3(dir.x, dir.y, 0);
+        const vec2 = new Vector3(dir.z, vec1.distanceSquared(vec1), 0);
+        const vec3 = vec2.normalize;
+        this.Rotation = new Vector3(Math.atan2(vec3.x, vec3.y) * 57.295779513082323, this.Rotation.y, Math.atan2(dir.x, dir.y) * -57.295779513082323);
+    }
+    //   public get UpVector() : Vector3 {
+    //       return Matrix.Up;
+    //   }
+    get ForwardVector() {
+        const rotation = Vector3.multiply(this.Rotation, Math.PI / 180);
+        const normalized = Vector3.normalize(new Vector3(-Math.sin(rotation.z) * Math.abs(Math.cos(rotation.x)), Math.cos(rotation.z) * Math.abs(Math.cos(rotation.x)), Math.sin(rotation.x)));
+        return new Vector3(normalized.x, normalized.y, normalized.z);
+    }
+    //   public get RightVector() : Vector3 {
+    //       return Matrix.Right;
+    //   }
+    // public Vector3 GetOffsetPosition(Vector3 offset) {
+    //     return Vector3.TransformCoordinate(offset, Matrix);
+    // }
+    // public Vector3 GetPositionOffset(Vector3 worldCoords) {
+    //     return Vector3.TransformCoordinate(worldCoords, Matrix.Invert(Matrix));
+    // }
+    get FieldOfView() {
+        return GetCamFov(this.handle);
+    }
+    set FieldOfView(fieldOfView) {
+        SetCamFov(this.handle, fieldOfView);
+    }
+    get NearClip() {
+        return GetCamNearClip(this.handle);
+    }
+    set NearClip(nearClip) {
+        SetCamNearClip(this.handle, nearClip);
+    }
+    get FarClip() {
+        return GetCamFarClip(this.handle);
+    }
+    set FarClip(farClip) {
+        SetCamFarClip(this.handle, farClip);
+    }
+    set NearDepthOfField(nearDepthOfField) {
+        SetCamNearDof(this.handle, nearDepthOfField);
+    }
+    get FarDepthOfField() {
+        return GetCamFarDof(this.handle);
+    }
+    set FarDepthOfField(farDepthOfField) {
+        SetCamFarDof(this.handle, farDepthOfField);
+    }
+    set DepthOfFieldStrength(strength) {
+        SetCamDofStrength(this.handle, strength);
+    }
+    set MotionBlurStrength(strength) {
+        SetCamMotionBlurStrength(this.handle, strength);
+    }
+    shake(shakeType, amplitude) {
+        ShakeCam(this.handle, Camera.shakeNames[Number(shakeType)], amplitude);
+    }
+    stopShaking() {
+        StopCamShaking(this.handle, true);
+    }
+    get IsShaking() {
+        return IsCamShaking(this.handle);
+    }
+    set ShakeAmplitude(amplitude) {
+        SetCamShakeAmplitude(this.handle, amplitude);
+    }
+    async playAnim(animName, animDict, position, rotation) {
+        await LoadAnimDict(animDict);
+        PlayCamAnim(this.handle, animName, animDict, position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, false, 2);
+        RemoveAnimDict(animDict);
+    }
+    pointAt(target, offset = new Vector3(0, 0, 0)) {
+        if (target instanceof BaseEntity) {
+            PointCamAtEntity(this.handle, target.Handle, offset.x, offset.y, offset.z, true);
+        }
+        else if (target instanceof PedBone) {
+            PointCamAtPedBone(this.handle, target.Owner.Handle, target.Index, offset.x, offset.y, offset.z, true);
+        }
+        else {
+            PointCamAtCoord(this.handle, target.x, target.y, target.z);
+        }
+    }
+    stopPointing() {
+        StopCamPointing(this.handle);
+    }
+    interpTo(to, duration, easePosition, easeRotation) {
+        SetCamActiveWithInterp(to.handle, this.handle, duration, Number(easePosition), Number(easeRotation));
+    }
+    get IsInterpolating() {
+        return IsCamInterpolating(this.handle);
+    }
+    attachTo(object, offset) {
+        if (object instanceof BaseEntity) {
+            AttachCamToEntity(this.handle, object.Handle, offset.x, offset.y, offset.z, true);
+        }
+        else if (object instanceof PedBone) {
+            AttachCamToPedBone(this.handle, object.Owner.Handle, object.Index, offset.x, offset.y, offset.z, true);
+        }
+    }
+    detach() {
+        DetachCam(this.handle);
+    }
+    delete() {
+        DestroyCam(this.handle, false);
+    }
+    exists() {
+        return DoesCamExist(this.handle);
+    }
+}
+Camera.shakeNames = [
+    'HAND_SHAKE',
+    'SMALL_EXPLOSION_SHAKE',
+    'MEDIUM_EXPLOSION_SHAKE',
+    'LARGE_EXPLOSION_SHAKE',
+    'JOLT_SHAKE',
+    'VIBRATE_SHAKE',
+    'ROAD_VIBRATION_SHAKE',
+    'DRUNK_SHAKE',
+    'SKY_DIVING_SHAKE',
+    'FAMILY5_DRUG_TRIP_SHAKE',
+    'DEATH_FAIL_IN_EFFECT_SHAKE',
+];

package/lib/client/Checkpoint.d.ts

@@ -0,0 +1,18 @@
+import { CheckpointIcon } from './enums';
+import { Vector3 } from './utils';
+export declare class Checkpoint {
+    private handle;
+    private position;
+    private targetPosition;
+    private icon;
+    private radius;
+    constructor(handle: number);
+    get Position(): Vector3;
+    set Position(position: Vector3);
+    get TargetPosition(): Vector3;
+    set TargetPosition(targetPosition: Vector3);
+    get Icon(): CheckpointIcon;
+    set Icon(icon: CheckpointIcon);
+    get Radius(): number;
+    set Radius(radius: number);
+}

package/lib/client/Checkpoint.js

@@ -0,0 +1,42 @@
+import { CheckpointIcon } from './enums';
+import { Vector3 } from './utils';
+export class Checkpoint {
+    constructor(handle) {
+        this.position = new Vector3(0, 0, 0);
+        this.targetPosition = new Vector3(0, 0, 0);
+        this.icon = CheckpointIcon.Empty;
+        this.radius = 0;
+        this.handle = handle;
+    }
+    get Position() {
+        return this.position;
+    }
+    set Position(position) {
+        this.position = position;
+    }
+    get TargetPosition() {
+        return this.targetPosition;
+    }
+    set TargetPosition(targetPosition) {
+        this.targetPosition = targetPosition;
+    }
+    get Icon() {
+        return this.icon;
+    }
+    set Icon(icon) {
+        this.icon = icon;
+    }
+    // TODO
+    //   public get CustomIcon(): CheckpointIcon {
+    //     return this.icon;
+    //   }
+    //     public set CustomIcon(icon: CheckpointIcon) {
+    //     this.icon = icon;
+    //   }
+    get Radius() {
+        return this.radius;
+    }
+    set Radius(radius) {
+        this.radius = radius;
+    }
+}

package/lib/client/Events.d.ts

@@ -0,0 +1,11 @@
+export type NetEvent = (...args: any[]) => void;
+export declare class Events {
+    /**
+     * An onNet wrapper that properly converts the type into the correct type
+     */
+    onNet: (eventName: string, event: NetEvent) => void;
+    /**
+     * An on wrapper that properly converts the classes
+     */
+    on: (eventName: string, event: NetEvent) => void;
+}

package/lib/client/Events.js

@@ -0,0 +1,73 @@
+/* eslint-disable */
+import { ClassTypes } from './enums/ClassTypes';
+import { Ped } from './models/Ped';
+import { Vector2 } from './utils/Vector2';
+import { Vector3 } from './utils/Vector3';
+import { Vector4 } from './utils/Vector4';
+import { Player } from './models/Player';
+import { Prop } from './models/Prop';
+import { Vehicle } from './models/Vehicle';
+import { Entity } from './models/Entity';
+const getClassFromArguments = (...args) => {
+    const newArgs = [];
+    for (const arg of args) {
+        switch (arg.type) {
+            case ClassTypes.Vector2: {
+                newArgs.push(Vector2.create(arg));
+                continue;
+            }
+            case ClassTypes.Vector3: {
+                newArgs.push(Vector3.create(arg));
+                continue;
+            }
+            case ClassTypes.Vector4: {
+                newArgs.push(Vector4.create(arg));
+                continue;
+            }
+            case ClassTypes.Ped: {
+                newArgs.push(Ped.fromNetworkId(arg.handle));
+                continue;
+            }
+            case ClassTypes.Player: {
+                newArgs.push(Player.fromServerId(arg.source));
+                continue;
+            }
+            case ClassTypes.Prop: {
+                newArgs.push(Prop.fromNetworkId(arg.handle));
+                continue;
+            }
+            case ClassTypes.Vehicle: {
+                newArgs.push(Vehicle.fromNetworkId(arg.netId));
+                continue;
+            }
+            case ClassTypes.Entity: {
+                newArgs.push(Entity.fromNetworkId(arg.netId));
+                continue;
+            }
+            default: {
+                newArgs.push(arg);
+            }
+        }
+    }
+    return newArgs;
+};
+export class Events {
+    constructor() {
+        /**
+         * An onNet wrapper that properly converts the type into the correct type
+         */
+        this.onNet = (eventName, event) => {
+            onNet(eventName, (...args) => {
+                event(...getClassFromArguments(...args));
+            });
+        };
+        /**
+         * An on wrapper that properly converts the classes
+         */
+        this.on = (eventName, event) => {
+            on(eventName, (...args) => {
+                event(...getClassFromArguments(...args));
+            });
+        };
+    }
+}