upd (fw/rpc):

- (rpc) removed unnecessary return type generics
- (fw) implemented synchronous versions of rpc events to omit waiting for response
- (fw) more descriptive docs

browser/package.json

@@ -13,6 +13,7 @@
     ".": "./src/index.ts"
   },
   "publishConfig": {
+    "access": "public",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {

browser/src/core/browser.ts

@@ -1,9 +1,9 @@
-import { Helper } from './helper'
+import { FW_Helper } from './helper'
 import { rpc } from './rpc'
 import type * as T from '../types'
 
 /** Browser-side interactions */
-export class Browser extends Helper {
+export class FW_Browser extends FW_Helper {
     constructor() {
         super()
     }
@@ -29,7 +29,7 @@ export class Browser extends Helper {
      *
      * @param eventName - The name of the event to register
      * @param callback - The callback function to be executed when the event is triggered
-     * @returns {Browser} The current browser instance, enabling method chaining
+     * @returns {FW_Browser} The current browser instance, enabling method chaining
      *
      * @example
      * // Registering an event
@@ -39,10 +39,10 @@ export class Browser extends Helper {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public register<EventName extends T.RageFW_BrowserEvent>(
+    public register<EventName extends T.FW_BrowserEvent>(
         eventName: EventName,
-        callback: T.RageFW_BrowserCallback<EventName>,
+        callback: T.FW_BrowserCallback<EventName>,
-    ): Browser {
+    ): FW_Browser {
         this.log_('register', eventName, callback)
 
         rpc.register<
@@ -58,7 +58,7 @@ export class Browser extends Helper {
      * Unregisters a browser event, removing the associated callback
      *
      * @param eventName - The name of the event to unregister
-     * @returns {Browser} The current browser instance, enabling method chaining
+     * @returns {FW_Browser} The current browser instance, enabling method chaining
      *
      * @example
      * // Unregistering an event
@@ -66,21 +66,51 @@ export class Browser extends Helper {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public unregister<EventName extends T.RageFW_BrowserEvent>(
+    public unregister<EventName extends T.FW_BrowserEvent>(
         eventName: EventName,
-    ): Browser {
+    ): FW_Browser {
         rpc.unregister<EventName>(eventName)
 
         return this
     }
 
     /**
-     * Triggers a browser event from the browser with arguments from shared types
+     * Triggers a browser event from the browser with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``call`` or ``emit``
      *
      * @param eventName - The name of the browser event to trigger
      * @param [args] - Arguments for the browser event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a browser event without arguments
+     * fw.event.trigger("browserEventName")
+     *
+     * @example
+     * // Triggering a browser event with arguments
+     * fw.event.trigger("browserEventName", ["message to me"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public trigger<EventName extends T.FW_BrowserEvent>(
+        eventName: EventName,
+        ...args: T._BrowserEventHasArgs<EventName> extends true
+            ? [T.FW_BrowserArgs<EventName>]
+            : []
+    ): void {
+        this.log_('[RPC](trigger):', eventName, ...args)
+
+        rpc.call<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous browser event from the browser with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callAsync`` or ``emitAsync``
+     *
+     * @param eventName - The name of the browser event to trigger
+     * @param [args] - Arguments for the browser event, if present
      * @returns {Promise} resolving to the browser's response for the event
      *
      * @example
@@ -93,28 +123,58 @@ export class Browser extends Helper {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async trigger<EventName extends T.RageFW_BrowserEvent>(
+    public async triggerAsync<EventName extends T.FW_BrowserEvent>(
         eventName: EventName,
         ...args: T._BrowserEventHasArgs<EventName> extends true
-            ? [T.RageFW_BrowserArgs<EventName>]
+            ? [T.FW_BrowserArgs<EventName>]
             : []
-    ): Promise<T.RageFW_BrowserReturn<EventName>> {
+    ): Promise<T.FW_BrowserReturn<EventName>> {
         this.log_('[RPC](trigger):', eventName, ...args)
 
-        return await rpc.call<
+        return await rpc.callAsync<
             typeof args,
             EventName,
-            T.RageFW_BrowserReturn<EventName>
+            T.FW_BrowserReturn<EventName>
         >(eventName, args)
     }
 
     /**
-     * Triggers a server event from the browser with arguments from shared types
+     * Triggers a server event from the browser with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callServer`` or ``emitServer``
      *
      * @param eventName - The name of the server event to trigger
      * @param [args] - Arguments for the server event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a server event without arguments
+     * fw.event.triggerServer("serverEventName")
+     *
+     * @example
+     * // Triggering a server event with arguments
+     * fw.event.triggerServer("serverEventName", ["message to server"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public triggerServer<EventName extends T.FW_ServerEvent>(
+        eventName: EventName,
+        ...args: T._ServerEventHasArgs<EventName> extends true
+            ? [T.FW_ServerArgs<EventName>]
+            : []
+    ): void {
+        this.log_('[RPC](triggerServer):', eventName, ...args)
+
+        rpc.callServer<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous server event from the browser with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callServerAsync`` or ``emitServerAsync``
+     *
+     * @param eventName - The name of the server event to trigger
+     * @param [args] - Arguments for the server event, if present
      * @returns {Promise} resolving to the server's response for the event
      *
      * @example
@@ -127,28 +187,58 @@ export class Browser extends Helper {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerServer<EventName extends T.RageFW_ServerEvent>(
+    public async triggerServerAsync<EventName extends T.FW_ServerEvent>(
         eventName: EventName,
         ...args: T._ServerEventHasArgs<EventName> extends true
-            ? [T.RageFW_ServerArgs<EventName>]
+            ? [T.FW_ServerArgs<EventName>]
             : []
-    ): Promise<T.RageFW_ServerReturn<EventName>> {
+    ): Promise<T.FW_ServerReturn<EventName>> {
         this.log_('[RPC](triggerServer):', eventName, ...args)
 
-        return await rpc.callServer<
+        return await rpc.callServerAsync<
             typeof args,
             EventName,
-            T.RageFW_ServerReturn<EventName>
+            T.FW_ServerReturn<EventName>
         >(eventName, args)
     }
 
     /**
-     * Triggers a client event from the browser with arguments from shared types
+     * Triggers a browser event from the browser with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callClient`` or ``emitClient``
      *
      * @param eventName - The name of the client event to trigger
      * @param [args] - Arguments for the client event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a client event without arguments
+     * fw.event.triggerClient("clientEventName")
+     *
+     * @example
+     * // Triggering a client event with arguments
+     * fw.event.triggerClient("clientEventName", ["message to client"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public triggerClient<EventName extends T.FW_ClientEvent>(
+        eventName: EventName,
+        ...args: T._ClientEventHasArgs<EventName> extends true
+            ? [T.FW_ClientArgs<EventName>]
+            : []
+    ): void {
+        this.log_('[RPC](triggerClient):', eventName, ...args)
+
+        rpc.callClient<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous client event from the browser with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callClientAsync`` or ``emitClientAsync``
+     *
+     * @param eventName - The name of the client event to trigger
+     * @param [args] - Arguments for the client event, if present
      * @returns {Promise} resolving to the client's response for the event
      *
      * @example
@@ -161,22 +251,18 @@ export class Browser extends Helper {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerClient<EventName extends T.RageFW_ClientEvent>(
+    public async triggerClientAsync<EventName extends T.FW_ClientEvent>(
         eventName: EventName,
         ...args: T._ClientEventHasArgs<EventName> extends true
-            ? [T.RageFW_ClientArgs<EventName>]
+            ? [T.FW_ClientArgs<EventName>]
             : []
-    ): Promise<T.RageFW_ClientReturn<EventName>> {
+    ): Promise<T.FW_ClientReturn<EventName>> {
         this.log_('[RPC](triggerClient):', eventName, ...args)
 
-        return await rpc.callClient<
+        return await rpc.callClientAsync<
             typeof args,
             EventName,
-            T.RageFW_ClientReturn<EventName>
+            T.FW_ClientReturn<EventName>
         >(eventName, args)
     }
 }
-
-// new Browser()
-//     .register('customCefEvent', async (a, b) => true)
-//     .triggerServer('customServerEvent', ['', 1])

browser/src/core/helper.ts

@@ -1,4 +1,4 @@
-export class Helper {
+export class FW_Helper {
     protected debugLogs_: boolean = false
     protected customLogger_:
         | undefined

browser/src/index.ts

@@ -1,4 +1,4 @@
-import { Browser, rpc } from './core'
+import { FW_Browser, rpc } from './core'
 
 /**
  * Package used on a browser-side of your Rage:MP Server
@@ -7,10 +7,7 @@ import { Browser, rpc } from './core'
  */
 export const fw = {
     /** Browser-side interactions */
-    event: new Browser(),
+    event: new FW_Browser(),
     /** ``rage-fw-rpc`` instance used under the hood. It is highly recommended to use this one if you need it instead of creating a new instance */
     rpc,
 }
-;(async () => {
-    await fw.event.triggerClient('cefReady')
-})()

browser/src/types/browser.ts

@@ -1,40 +1,41 @@
-import type { RageFW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
 
-export type { RageFW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
+export type { FW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available browser event names
  * These only include custom events
  */
-export type RageFW_BrowserEvent = keyof RageFW_ICustomBrowserEvent
+export type FW_BrowserEvent = keyof FW_ICustomBrowserEvent
 
 /**
  * Array of arguments of an event you pass as a generic
  * These only include custom browser events
  */
-export type RageFW_BrowserArgs<K extends RageFW_BrowserEvent> = Parameters<
+export type FW_BrowserArgs<K extends FW_BrowserEvent> = Parameters<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
 /**
  * Return type of event you pass as a generic
  * These only include custom browser events
  */
-export type RageFW_BrowserReturn<K extends RageFW_BrowserEvent> = ReturnType<
+export type FW_BrowserReturn<K extends FW_BrowserEvent> = ReturnType<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
 /**
  * Callback (function) of event you pass as a generic
  * These only include custom browser events
  */
-export type RageFW_BrowserCallback<K extends keyof RageFW_ICustomBrowserEvent> =
+export type FW_BrowserCallback<K extends keyof FW_ICustomBrowserEvent> = (
-    (...args: RageFW_BrowserArgs<K>) => Promise<RageFW_BrowserReturn<K>>
+    ...args: FW_BrowserArgs<K>
+) => Promise<FW_BrowserReturn<K>>
 
 export type _BrowserEventHasArgs<
-    EventName extends keyof RageFW_ICustomBrowserEvent,
+    EventName extends keyof FW_ICustomBrowserEvent,
-> = keyof RageFW_ICustomBrowserEvent extends never
+> = keyof FW_ICustomBrowserEvent extends never
     ? false
-    : Parameters<RageFW_ICustomBrowserEvent[EventName]>[0] extends undefined
+    : Parameters<FW_ICustomBrowserEvent[EventName]>[0] extends undefined
       ? false
       : true

browser/src/types/client.ts

@@ -1,33 +1,32 @@
-import type { RageFW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
 
-export type { RageFW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
+export type { FW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available client event names
- * These only include custom events and some extras from RageFW
+ * These only include custom events and some internals for RageFW
  */
-export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
+export type FW_ClientEvent = keyof FW_ICustomClientEvent
 
 /**
  * Array of arguments of event you pass as a generic
  * These only include custom client events
  */
-export type RageFW_ClientArgs<K extends RageFW_ClientEvent> = Parameters<
+export type FW_ClientArgs<K extends FW_ClientEvent> = Parameters<
-    RageFW_ICustomClientEvent[K]
+    FW_ICustomClientEvent[K]
 >
 
 /**
  * Return type of event you pass as a generic
  * These only include custom client events
  */
-export type RageFW_ClientReturn<K extends RageFW_ClientEvent> = ReturnType<
+export type FW_ClientReturn<K extends FW_ClientEvent> = ReturnType<
-    RageFW_ICustomClientEvent[K]
+    FW_ICustomClientEvent[K]
 >
 
-export type _ClientEventHasArgs<
+export type _ClientEventHasArgs<EventName extends keyof FW_ICustomClientEvent> =
-    EventName extends keyof RageFW_ICustomClientEvent,
+    keyof FW_ICustomClientEvent extends never
-> = keyof RageFW_ICustomClientEvent extends never
         ? false
-    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+        : Parameters<FW_ICustomClientEvent[EventName]>[0] extends undefined
           ? false
           : true

browser/src/types/index.ts

@@ -1,3 +1,3 @@
-export * from './browser'
+export type * from './browser'
-export * from './client'
+export type * from './client'
-export * from './server'
+export type * from './server'

browser/src/types/server.ts

@@ -1,33 +1,32 @@
-import type { RageFW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
 
-export type { RageFW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
+export type { FW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available server event names
  * These only include custom events
  */
-export type RageFW_ServerEvent = keyof RageFW_ICustomServerEvent
+export type FW_ServerEvent = keyof FW_ICustomServerEvent
 
 /**
  * Array of arguments of event you pass as a generic
  * These only include custom server events
  */
-export type RageFW_ServerArgs<K extends RageFW_ServerEvent> = Parameters<
+export type FW_ServerArgs<K extends FW_ServerEvent> = Parameters<
-    RageFW_ICustomServerEvent[K]
+    FW_ICustomServerEvent[K]
 >
 
 /**
  * Return type of event you pass as a generic
  * These only include custom server events
  */
-export type RageFW_ServerReturn<K extends RageFW_ServerEvent> = ReturnType<
+export type FW_ServerReturn<K extends FW_ServerEvent> = ReturnType<
-    RageFW_ICustomServerEvent[K]
+    FW_ICustomServerEvent[K]
 >
 
-export type _ServerEventHasArgs<
+export type _ServerEventHasArgs<EventName extends keyof FW_ICustomServerEvent> =
-    EventName extends keyof RageFW_ICustomServerEvent,
+    keyof FW_ICustomServerEvent extends never
-> = keyof RageFW_ICustomServerEvent extends never
         ? false
-    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+        : Parameters<FW_ICustomServerEvent[EventName]>[0] extends undefined
           ? false
           : true

client/package.json

@@ -13,6 +13,7 @@
     ".": "./src/index.ts"
   },
   "publishConfig": {
+    "access": "public",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {

client/src/core/client.ts

@@ -1,9 +1,9 @@
 import { rpc } from './rpc'
-import { Middleware } from './middleware'
+import { FW_Middleware } from './middleware'
 import type * as T from '../types'
 
 /** Client-side interactions */
-export class Client {
+export class FW_Client {
     /**
      * Registers a client event with an associated callback
      *
@@ -11,7 +11,7 @@ export class Client {
      * @param callback - The callback function to be executed when the event is triggered
      * @param [options] - Optional settings for callback execution
      * @param [options.middlewares] - Middleware functions to be checked before the callback executes
-     * @returns {Client} The current client instance, enabling method chaining
+     * @returns {FW_Client} The current client instance, enabling method chaining
      *
      * @example
      * // Registering an event
@@ -40,13 +40,13 @@ export class Client {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public register<EventName extends T.RageFW_ClientEvent>(
+    public register<EventName extends T.FW_ClientEvent>(
         eventName: EventName,
-        callback: T.RageFW_ClientCallback<EventName>,
+        callback: T.FW_ClientCallback<EventName>,
         options?: {
-            middlewares?: T.RageFW_MiddlewareOptions<EventName>
+            middlewares?: T.FW_MiddlewareOptions<EventName>
         },
-    ): Client {
+    ): FW_Client {
         rpc.register<
             Parameters<typeof callback>,
             ReturnType<typeof callback> | Promise<unknown>,
@@ -54,7 +54,7 @@ export class Client {
         >(eventName, async (...data) => {
             if (!options?.middlewares) return await callback(...data)
 
-            await Middleware.process(options.middlewares, callback, data)
+            await FW_Middleware.process(options.middlewares, callback, data)
         })
 
         return this
@@ -72,15 +72,11 @@ export class Client {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public unregister<EventName extends T.RageFW_ClientEvent>(
+    public unregister<EventName extends T.FW_ClientEvent>(
         eventName: EventName,
-    ): Client {
+    ): FW_Client {
         rpc.unregister<EventName>(eventName)
 
         return this
     }
 }
-
-// new Client()
-//     .register('customClientEvent', async (a, b) => true)
-//     .unregister('customClientEvent')

client/src/core/logger.ts

@@ -1,7 +1,7 @@
 /**
  * Used to log to a client in-game console
  */
-export class Logger {
+export class FW_Logger {
     /**
      * Informational logs. Colored in white
      *
@@ -10,7 +10,7 @@ export class Logger {
      */
     public info(...message: unknown[]) {
         mp.console.logInfo(
-            `[${new Date().toLocaleTimeString()}] [INFO] ${message.join(' ')}`,
+            `[${new Date().toLocaleTimeString(undefined, { hour: 'numeric', minute: 'numeric', second: 'numeric', fractionalSecondDigits: 2 })}] [INFO] ${message.join(' ')}`,
         )
     }
 
@@ -22,7 +22,7 @@ export class Logger {
      */
     public warn(...message: unknown[]) {
         mp.console.logWarning(
-            `[${new Date().toLocaleTimeString()}] [WARN] ${message.join(' ')}`,
+            `[${new Date().toLocaleTimeString(undefined, { hour: 'numeric', minute: 'numeric', second: 'numeric', fractionalSecondDigits: 2 })}] [WARN] ${message.join(' ')}`,
         )
     }
 
@@ -34,7 +34,7 @@ export class Logger {
      */
     public error(...message: unknown[]) {
         mp.console.logError(
-            `[${new Date().toLocaleTimeString()}] [ERROR] ${message.join(' ')}`,
+            `[${new Date().toLocaleTimeString(undefined, { hour: 'numeric', minute: 'numeric', second: 'numeric', fractionalSecondDigits: 2 })}] [ERROR] ${message.join(' ')}`,
         )
     }
 }

client/src/core/middleware.ts

@@ -1,12 +1,12 @@
 import type * as T from '../types'
 
-export class Middleware {
+export class FW_Middleware {
     constructor() {}
 
-    private static async execute<EventName extends T.RageFW_ClientEvent>(
+    private static async execute<EventName extends T.FW_ClientEvent>(
-        middlewares: T.RageFW_MiddlewareFunction<EventName>[],
+        middlewares: T.FW_MiddlewareFunction<EventName>[],
-        args: T.RageFW_ClientArgs<EventName>,
+        args: T.FW_ClientArgs<EventName>,
-    ): Promise<T.RageFW_MiddlewareResponseInternal> {
+    ): Promise<T.FW_MiddlewareResponseInternal> {
         for (let i = 0; i < middlewares.length; i++) {
             const result = await middlewares[i](...args)
 
@@ -21,20 +21,20 @@ export class Middleware {
         }
     }
 
-    public static async process<EventName extends T.RageFW_ClientEvent>(
+    public static async process<EventName extends T.FW_ClientEvent>(
-        middlewareOptions: T.RageFW_MiddlewareOptions<EventName>,
+        middlewareOptions: T.FW_MiddlewareOptions<EventName>,
-        callback: T.RageFW_ClientCallback<EventName>,
+        callback: T.FW_ClientCallback<EventName>,
-        args: T.RageFW_ClientArgs<EventName>,
+        args: T.FW_ClientArgs<EventName>,
     ) {
         if (Array.isArray(middlewareOptions)) {
-            const middlewaresResponse = await Middleware.execute(
+            const middlewaresResponse = await FW_Middleware.execute(
                 middlewareOptions,
                 args,
             )
 
             if (middlewaresResponse.success) return await callback(...args)
         } else {
-            const middlewaresResponse = await Middleware.execute(
+            const middlewaresResponse = await FW_Middleware.execute(
                 middlewareOptions.executables,
                 args,
             )

client/src/core/player.ts

@@ -2,7 +2,7 @@ import { rpc } from './rpc'
 import type * as T from '../types'
 
 /** Handles event manipulations that require player to be present in context */
-export class Player {
+export class FW_Player {
     private _browser: BrowserMp | undefined = undefined
 
     /**
@@ -14,12 +14,40 @@ export class Player {
     }
 
     /**
-     * Triggers a client event from the client with arguments from shared types
+     * Triggers a client event from the client with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``call`` or ``emit``
      *
      * @param eventName - The name of the client event to trigger
      * @param [args] - Arguments for the client event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a client event without arguments
+     * fw.player.trigger("clientEventName")
+     *
+     * @example
+     * // Triggering a client event with arguments
+     * fw.player.trigger("clientEventName", ["message to me"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public trigger<EventName extends keyof T.FW_ICustomClientEvent>(
+        eventName: EventName,
+        ...args: T._ClientEventHasArgs<EventName> extends true
+            ? [T.FW_ClientArgs<EventName>]
+            : []
+    ): void {
+        rpc.call<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous client event from the client with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callAsync`` or ``emitAsync``
+     *
+     * @param eventName - The name of the client event to trigger
+     * @param [args] - Arguments for the client event, if present
      * @returns {Promise} resolving to the client's response for the event
      *
      * @example
@@ -32,26 +60,54 @@ export class Player {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async trigger<EventName extends keyof T.RageFW_ICustomClientEvent>(
+    public async triggerAsync<EventName extends keyof T.FW_ICustomClientEvent>(
         eventName: EventName,
         ...args: T._ClientEventHasArgs<EventName> extends true
-            ? [T.RageFW_ClientArgs<EventName>]
+            ? [T.FW_ClientArgs<EventName>]
             : []
-    ): Promise<T.RageFW_ClientReturn<EventName>> {
+    ): Promise<T.FW_ClientReturn<EventName>> {
-        return await rpc.call<
+        return await rpc.callAsync<
             typeof args,
             EventName,
-            T.RageFW_ClientReturn<EventName>
+            T.FW_ClientReturn<EventName>
         >(eventName, args)
     }
 
     /**
-     * Triggers a server event from the client with arguments from shared types
+     * Triggers a server event from the client with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callServer`` or ``emitServer``
      *
      * @param eventName - The name of the server event to trigger
      * @param [args] - Arguments for the server event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a server event without arguments
+     * fw.player.triggerServer("serverEventName")
+     *
+     * @example
+     * // Triggering a server event with arguments
+     * fw.player.triggerServer("serverEventName", ["message to server"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public triggerServer<EventName extends T.FW_ServerEvent>(
+        eventName: EventName,
+        ...args: T._ServerEventHasArgs<EventName> extends true
+            ? [T.FW_ServerArgs<EventName>]
+            : []
+    ): void {
+        rpc.callServer<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous server event from the client with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callServerAsync`` or ``emitServerAsync``
+     *
+     * @param eventName - The name of the server event to trigger
+     * @param [args] - Arguments for the server event, if present
      * @returns {Promise} resolving to the server's response for the event
      *
      * @example
@@ -64,26 +120,57 @@ export class Player {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerServer<EventName extends T.RageFW_ServerEvent>(
+    public async triggerServerAsync<EventName extends T.FW_ServerEvent>(
         eventName: EventName,
         ...args: T._ServerEventHasArgs<EventName> extends true
-            ? [T.RageFW_ServerArgs<EventName>]
+            ? [T.FW_ServerArgs<EventName>]
             : []
-    ): Promise<T.RageFW_ClientServerReturn<EventName>> {
+    ): Promise<T.FW_ClientServerReturn<EventName>> {
-        return await rpc.callServer<
+        return await rpc.callServerAsync<
             typeof args,
             EventName,
-            T.RageFW_ClientServerReturn<EventName>
+            T.FW_ClientServerReturn<EventName>
         >(eventName, args)
     }
 
     /**
-     * Triggers a browser event from the client with arguments from shared types
+     * Triggers a browser event from the client with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callBrowser`` or ``emitBrowser``
      *
      * @param eventName - The name of the browser event to trigger
      * @param [args] - Arguments for the browser event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a browser event without arguments
+     * fw.player.triggerBrowser("browserEventName")
+     *
+     * @example
+     * // Triggering a browser event with arguments
+     * fw.player.triggerBrowser("browserEventName", ["message to browser"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public triggerBrowser<EventName extends T.FW_BrowserEvent>(
+        eventName: EventName,
+        ...args: T._BrowserEventHasArgs<EventName> extends true
+            ? [T.FW_BrowserArgs<EventName>]
+            : []
+    ): void {
+        if (!this._browser)
+            throw new Error('You need to initialize browser first')
+
+        rpc.callBrowser<typeof args, EventName>(eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous browser event from the client with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callBrowserAsync`` or ``emitBrowserAsync``
+     *
+     * @param eventName - The name of the browser event to trigger
+     * @param [args] - Arguments for the browser event, if present
      * @returns {Promise} resolving to the browser's response for the event
      *
      * @example
@@ -96,23 +183,19 @@ export class Player {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerBrowser<EventName extends T.RageFW_BrowserEvent>(
+    public async triggerBrowserAsync<EventName extends T.FW_BrowserEvent>(
         eventName: EventName,
         ...args: T._BrowserEventHasArgs<EventName> extends true
-            ? [T.RageFW_BrowserArgs<EventName>]
+            ? [T.FW_BrowserArgs<EventName>]
             : []
-    ): Promise<T.RageFW_BrowserReturn<EventName>> {
+    ): Promise<T.FW_BrowserReturn<EventName>> {
         if (!this._browser)
             throw new Error('You need to initialize browser first')
 
-        return await rpc.callBrowser<
+        return await rpc.callBrowserAsync<
             typeof args,
             EventName,
-            T.RageFW_BrowserReturn<EventName>
+            T.FW_BrowserReturn<EventName>
         >(eventName, args)
     }
 }
-
-// new Player().trigger('customClientEvent', ['', 1])
-// new Player().triggerServer('customServerEvent', ['', 1])
-// new Player().triggerBrowser('customCefEvent', ['', 1])

client/src/index.ts

@@ -1,6 +1,6 @@
-import { Client, Logger, Player, rpc } from './core'
+import { FW_Client, FW_Logger, FW_Player, rpc } from './core'
 
-export type { RageFW_MiddlewareFunction } from './types'
+export type { FW_MiddlewareFunction } from './types'
 
 /**
  * Package used on a client-side of your Rage:MP Server
@@ -9,13 +9,13 @@ export type { RageFW_MiddlewareFunction } from './types'
  */
 export const fw = {
     /** Client-side interactions */
-    event: new Client(),
+    event: new FW_Client(),
     /** Handles event manipulations that require player to be present in context */
-    player: new Player(),
+    player: new FW_Player(),
     /** Handles functions used to interact with the client environment */
     system: {
         /** Used to log in a client in-game console */
-        log: new Logger(),
+        log: new FW_Logger(),
     },
     /** ``rage-fw-rpc`` instance used under the hood. It is highly recommended to use this one if you need it instead of creating a new instance */
     rpc,

client/src/types/browser.ts

@@ -1,29 +1,29 @@
 /// <reference types="@ragempcommunity/types-client" />
 
-import type { RageFW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available browser event names callable from client
  * These only include custom events
  */
-export type RageFW_BrowserEvent = keyof RageFW_ICustomBrowserEvent
+export type FW_BrowserEvent = keyof FW_ICustomBrowserEvent
 
 /**
  * Array of arguments for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_BrowserArgs<K extends RageFW_BrowserEvent> = Parameters<
+export type FW_BrowserArgs<K extends FW_BrowserEvent> = Parameters<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
-export type RageFW_BrowserReturn<K extends RageFW_BrowserEvent> = ReturnType<
+export type FW_BrowserReturn<K extends FW_BrowserEvent> = ReturnType<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
 export type _BrowserEventHasArgs<
-    EventName extends keyof RageFW_ICustomBrowserEvent,
+    EventName extends keyof FW_ICustomBrowserEvent,
-> = keyof RageFW_ICustomBrowserEvent extends never
+> = keyof FW_ICustomBrowserEvent extends never
     ? false
-    : Parameters<RageFW_ICustomBrowserEvent[EventName]>[0] extends undefined
+    : Parameters<FW_ICustomBrowserEvent[EventName]>[0] extends undefined
       ? false
       : true

client/src/types/client.ts

@@ -1,24 +1,22 @@
 /// <reference types="@ragempcommunity/types-client" />
 
-import type { RageFW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
 
-export type { RageFW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
+export type { FW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available client event names
  * These include custom and system events
  */
-export type RageFW_ClientEvent =
+export type FW_ClientEvent = keyof FW_ICustomClientEvent | keyof IClientEvents
-    | keyof RageFW_ICustomClientEvent
-    | keyof IClientEvents
 
 /**
  * Array of arguments for an event, name of which you pass as a generic
  * These include custom and system events
  */
-export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
+export type FW_ClientArgs<K extends FW_ClientEvent> =
-    K extends keyof RageFW_ICustomClientEvent
+    K extends keyof FW_ICustomClientEvent
-        ? Parameters<RageFW_ICustomClientEvent[K]>
+        ? Parameters<FW_ICustomClientEvent[K]>
         : K extends keyof IClientEvents
           ? Parameters<IClientEvents[K]>
           : never
@@ -27,9 +25,9 @@ export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
  * Return type for an event, name of which you pass as a generic
  * These include custom and system events
  */
-export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
+export type FW_ClientReturn<K extends FW_ClientEvent> =
-    K extends keyof RageFW_ICustomClientEvent
+    K extends keyof FW_ICustomClientEvent
-        ? ReturnType<RageFW_ICustomClientEvent[K]>
+        ? ReturnType<FW_ICustomClientEvent[K]>
         : K extends keyof IClientEvents
           ? ReturnType<IClientEvents[K]>
           : void
@@ -38,17 +36,16 @@ export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
  * Callback (function) for an event, name of which you pass as a generic
  * These include custom and system events
  */
-export type RageFW_ClientCallback<K extends RageFW_ClientEvent> = (
+export type FW_ClientCallback<K extends FW_ClientEvent> = (
-    ...args: RageFW_ClientArgs<K>
+    ...args: FW_ClientArgs<K>
-) => Promise<RageFW_ClientReturn<K>>
+) => Promise<FW_ClientReturn<K>>
 
 /**
  *
  */
-export type _ClientEventHasArgs<
+export type _ClientEventHasArgs<EventName extends keyof FW_ICustomClientEvent> =
-    EventName extends keyof RageFW_ICustomClientEvent,
+    keyof FW_ICustomClientEvent extends never
-> = keyof RageFW_ICustomClientEvent extends never
         ? false
-    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+        : Parameters<FW_ICustomClientEvent[EventName]>[0] extends undefined
           ? false
           : true

client/src/types/index.ts

@@ -1,4 +1,4 @@
-export * from './browser'
+export type * from './browser'
-export * from './client'
+export type * from './client'
-export * from './middleware'
+export type * from './middleware'
-export * from './server'
+export type * from './server'

client/src/types/middleware.ts

@@ -1,26 +1,25 @@
 import type * as T from './client'
 
-export type RageFW_MiddlewareResponse =
+export type FW_MiddlewareResponse =
     | {
           success: boolean
           message?: string
       }
     | boolean
 
-export type RageFW_MiddlewareResponseInternal = {
+export type FW_MiddlewareResponseInternal = {
     success: boolean
     message?: string
     id?: number
 }
 
-export type RageFW_MiddlewareFunction<EventName extends T.RageFW_ClientEvent> =
+export type FW_MiddlewareFunction<EventName extends T.FW_ClientEvent> = (
-    (
+    ...args: T.FW_ClientArgs<EventName>
-        ...args: T.RageFW_ClientArgs<EventName>
+) => Promise<FW_MiddlewareResponse>
-    ) => Promise<RageFW_MiddlewareResponse>
 
-export type RageFW_MiddlewareOptions<EventName extends T.RageFW_ClientEvent> =
+export type FW_MiddlewareOptions<EventName extends T.FW_ClientEvent> =
-    | RageFW_MiddlewareFunction<EventName>[]
+    | FW_MiddlewareFunction<EventName>[]
     | {
-          executables: RageFW_MiddlewareFunction<EventName>[]
+          executables: FW_MiddlewareFunction<EventName>[]
           onError: (error: string) => unknown
       }

client/src/types/server.ts

@@ -1,38 +1,37 @@
 /// <reference types="@ragempcommunity/types-client" />
 
 import type {
-    RageFW_ICustomClientEvent,
+    FW_ICustomClientEvent,
-    RageFW_ICustomServerEvent,
+    FW_ICustomServerEvent,
 } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available server event names callable from client
  * These only include custom events
  */
-export type RageFW_ServerEvent = keyof RageFW_ICustomServerEvent
+export type FW_ServerEvent = keyof FW_ICustomServerEvent
 
 /**
  * Array of arguments for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ServerArgs<K extends RageFW_ServerEvent> =
+export type FW_ServerArgs<K extends FW_ServerEvent> =
-    K extends keyof RageFW_ICustomServerEvent
+    K extends keyof FW_ICustomServerEvent
-        ? Parameters<RageFW_ICustomServerEvent[K]>
+        ? Parameters<FW_ICustomServerEvent[K]>
         : never
 
 /**
  * Return type for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientServerReturn<K extends RageFW_ServerEvent> =
+export type FW_ClientServerReturn<K extends FW_ServerEvent> =
-    K extends keyof RageFW_ICustomServerEvent
+    K extends keyof FW_ICustomServerEvent
-        ? ReturnType<RageFW_ICustomServerEvent[K]>
+        ? ReturnType<FW_ICustomServerEvent[K]>
         : never
 
-export type _ServerEventHasArgs<
+export type _ServerEventHasArgs<EventName extends keyof FW_ICustomServerEvent> =
-    EventName extends keyof RageFW_ICustomServerEvent,
+    keyof FW_ICustomClientEvent extends never
-> = keyof RageFW_ICustomClientEvent extends never
         ? false
-    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+        : Parameters<FW_ICustomServerEvent[EventName]>[0] extends undefined
           ? false
           : true

rpc/index.d.ts

@@ -1,25 +1,8 @@
 export {}
 
-interface Mp {
+declare var global: Record<string, (...args: any[]) => unknown>
-    trigger(event: string, data?: any): void
-    events: {
-        add(event: string, data: any): void
-        call(event: string, data: any): void
-        callRemote(event: string, data: any): void
-        remove(event: string): void
-    }
-    joaat?: unknown
-    game: {
-        joaat?: unknown
-    }
-    console: {
-        logInfo: (...args: unknown[]) => void
-    }
-}
 
 declare global {
-    const mp: Mp
-    const global: Record<string, (...args: any[]) => unknown>
     interface Window {
         [p: string]: any
     }

rpc/package.json

@@ -2,8 +2,18 @@
   "private": false,
   "name": "@entityseven/rage-fw-rpc",
   "version": "0.2.5",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "access": "public",
     "main": "dist/index.js",
-  "types": "dist/src/index.d.ts",
+    "types": "dist/index.d.ts",
+    "exports": {
+      ".": "./dist/index.js"
+    }
+  },
   "scripts": {
     "build": "tsup",
     "start": "npx ./dist create"

rpc/src/browser.ts

@@ -1,3 +1,5 @@
+/// <reference types="@ragempcommunity/types-cef" />
+
 import { Wrapper } from './wrapper'
 import {
     Environment,

rpc/src/client.ts

@@ -1,3 +1,5 @@
+/// <reference types="@ragempcommunity/types-client" />
+
 import { Wrapper } from './wrapper'
 import {
     Environment,

rpc/src/index.ts

@@ -77,7 +77,7 @@ class Rpc extends Wrapper {
      *
      * @template CallbackArguments - An array of argument types that the callback function accepts
      * @template CallbackReturn - The type of the value returned by the callback function
-     * @template EventName - A string representing the event name or union of names
+     * @template EventName - A string or union representing the event name
      *
      * @param {EventName} eventName - The name of the event to register the callback for
      * @param {(...args: CallbackArguments) => CallbackReturn} cb - The callback function that is called when the event is triggered
@@ -116,7 +116,7 @@ class Rpc extends Wrapper {
     /**
      * Unregisters callback function for a specified event
      *
-     * @template EventName - A string representing the event name or union of names
+     * @template EventName - A string or union representing the event name
      *
      * @param {EventName} eventName - The name of the event to register the callback for
      *
@@ -133,54 +133,47 @@ class Rpc extends Wrapper {
         Utils.errorUnknownEnvironment(this.environment_)
 
         delete this.state_[eventName]
+        mp.events.remove(eventName)
     }
 
     /**
-     * Calls a client-side event from server or browser
+     * Calls a client-side event from browser or server. Use 'call' to call client from client
      *
      * @template Arguments - An array of argument types to be passed to the client event
-     * @template EventName - A string representing the client event name or union of names
+     * @template EventName - A string or union representing the client event name
-     * @template Return - The type of the value returned by the client event
      *
      * @param {EventName} eventName - The name of the client event to be called
      * @param {Arguments} [args] - Optional arguments to pass to the client event
-     * @returns {Promise<Return>} A promise resolving to the return value of the client event
+     * @returns {void}
      *
      * @example
-     * // Calls an event on client without specifying a player
+     * // Calls an event on a client without specifying a player
-     * callClient<[], string, object>('onDataRequest').then(response => {
+     * callClient<[], string, object>('onDataRequest')
-     *   console.log(`Received: ${response}`) //             ^ object
-     * })
      */
-    public async callClient<
+    public callClient<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
-        Return = unknown,
+    >(eventName: EventName, args?: Arguments): void
-    >(eventName: EventName, args?: Arguments): Promise<Return>
     /**
-     * Calls a client-side event from server or browser
+     * Calls a client-side event from server or server. Use 'call' to call client from client
      *
      * @template Arguments - An array of argument types to be passed to the client event
-     * @template EventName - A string representing the client event name or union of names
+     * @template EventName - A string or union representing the client event name
-     * @template Return - The type of the value returned by the client event
      *
      * @param {PlayerMp} player - The player for whom the client event is called
      * @param {EventName} eventName - The name of the client event to be called
      * @param {Arguments} [args] - Optional arguments to pass to the client event
-     * @returns {Promise<Return>} A promise resolving to the return value of the client event
+     * @returns {void} A promise resolving to the return value of the client event
      *
      * @example
-     * // Calls an event on client for a specific player
+     * // Calls an event on a client for a specific player
-     * callClient<[string, number], string, boolean>(player, 'onPlayerAction', ['jump', 2]).then(result => {
+     * callClient<[string, number], string, boolean>(player, 'onPlayerAction', ['jump', 2])
-     *   console.log(`Action success: ${result}`) //                                              ^ boolean
-     * })
      */
-    public async callClient<
+    public callClient<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
-        Return = unknown,
+    >(player: PlayerMp, eventName: EventName, args?: Arguments): void
-    >(player: PlayerMp, eventName: EventName, args?: Arguments): Promise<Return>
+    public callClient(
-    public async callClient(
         playerOrEventName: PlayerMp | string,
         eventNameOrArgs?: string | unknown[],
         args?: unknown[],
@@ -202,10 +195,7 @@ class Rpc extends Wrapper {
 
         if (this.environment_ === Environment.CLIENT) {
             // client
-            return await this.call(
+            this.call(playerOrEventName as string, args as unknown[])
-                playerOrEventName as string,
-                args as unknown[],
-            )
         }
 
         // server
@@ -227,7 +217,6 @@ class Rpc extends Wrapper {
             const dataRaw = Utils.prepareTransfer(state)
 
             playerOrEventName.call(Events.LOCAL_EVENT_LISTENER, [dataRaw])
-            return (await this.responseHandler(state.uuid)).data
         }
 
         // browser
@@ -249,7 +238,6 @@ class Rpc extends Wrapper {
             const dataRaw = Utils.prepareTransfer(state)
 
             mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
-            return (await this.responseHandler(state.uuid)).data
         }
 
         function _is1StParamPlayer(x: unknown): x is PlayerMp {
@@ -262,10 +250,201 @@ class Rpc extends Wrapper {
     }
 
     /**
-     * Calls a server-side event from browser or client
+     * Calls an asynchronous client-side event from server or browser, expecting a response. Use 'callAsync' to call client from client
+     *
+     * @template Arguments - An array of argument types to be passed to the client event
+     * @template EventName - A string or union representing the client event name
+     * @template Return - The type of the value returned by the client event
+     *
+     * @param {EventName} eventName - The name of the client event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the client event
+     * @returns {Promise<Return>} A promise resolving to the return value of the client event
+     *
+     * @example
+     * // Calls an event on a client without specifying a player
+     * callClient<[], string, object>('onDataRequest').then(response => {
+     *   console.log(`Received: ${response}`) //             ^ object
+     * })
+     */
+    public async callClientAsync<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+        Return = unknown,
+    >(eventName: EventName, args?: Arguments): Promise<Return>
+    /**
+     * Calls an asynchronous client-side event from server or browser, expecting a response. Use 'callAsync' to call client from client
+     *
+     * @template Arguments - An array of argument types to be passed to the client event
+     * @template EventName - A string or union representing the client event name
+     * @template Return - The type of the value returned by the client event
+     *
+     * @param {PlayerMp} player - The player for whom the client event is called
+     * @param {EventName} eventName - The name of the client event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the client event
+     * @returns {Promise<Return>} A promise resolving to the return value of the client event
+     *
+     * @example
+     * // Calls an event on a client for a specific player
+     * callClient<[string, number], string, boolean>(player, 'onPlayerAction', ['jump', 2]).then(result => {
+     *   console.log(`Action success: ${result}`) //                                              ^ boolean
+     * })
+     */
+    public async callClientAsync<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+        Return = unknown,
+    >(player: PlayerMp, eventName: EventName, args?: Arguments): Promise<Return>
+    public async callClientAsync(
+        playerOrEventName: PlayerMp | string,
+        eventNameOrArgs?: string | unknown[],
+        args?: unknown[],
+    ) {
+        if (_is1StParamPlayer(playerOrEventName)) {
+            this.log(
+                'callClientAsync',
+                eventNameOrArgs as string,
+                playerOrEventName,
+                eventNameOrArgs,
+                args,
+            )
+        } else {
+            this.log(
+                'callClientAsync',
+                playerOrEventName as string,
+                eventNameOrArgs,
+            )
+        }
+
+        if (this.forceBrowserDevMode_) return
+        Utils.errorUnknownEnvironment(this.environment_)
+
+        if (this.environment_ === Environment.CLIENT) {
+            // client
+            return await this.callAsync(
+                playerOrEventName as string,
+                args as unknown[],
+            )
+        }
+
+        // server
+        if (
+            this.environment_ === Environment.SERVER &&
+            _is1StParamPlayer(playerOrEventName) &&
+            _is2NdParamEventName(eventNameOrArgs)
+        ) {
+            let state: RPCState = {
+                uuid: Utils.generateUUID(),
+                eventName: eventNameOrArgs,
+                calledTo: Environment.CLIENT,
+                calledFrom: this.environment_,
+                knownError: undefined,
+                data: args as unknown[],
+                type: RPCEventType.EVENT,
+            }
+
+            const dataRaw = Utils.prepareTransfer(state)
+
+            playerOrEventName.call(Events.LOCAL_EVENT_LISTENER, [dataRaw])
+
+            return await this.responseHandler(state.uuid)
+                .then(r => r.data)
+                .catch((e: string) => {
+                    state.knownError = e
+                    return this.triggerError_(state)
+                })
+        }
+
+        // browser
+        if (
+            this.environment_ === Environment.BROWSER &&
+            !_is1StParamPlayer(playerOrEventName) &&
+            !_is2NdParamEventName(eventNameOrArgs)
+        ) {
+            const state: RPCState = {
+                uuid: Utils.generateUUID(),
+                eventName: playerOrEventName,
+                calledTo: Environment.CLIENT,
+                calledFrom: this.environment_,
+                knownError: undefined,
+                data: eventNameOrArgs,
+                type: RPCEventType.EVENT,
+            }
+
+            const dataRaw = Utils.prepareTransfer(state)
+
+            mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
+
+            return await this.responseHandler(state.uuid)
+                .then(r => r.data)
+                .catch((e: string) => {
+                    state.knownError = e
+                    return this.triggerError_(state)
+                })
+        }
+
+        function _is1StParamPlayer(x: unknown): x is PlayerMp {
+            return typeof x === 'object'
+        }
+
+        function _is2NdParamEventName(x: unknown): x is string {
+            return typeof x === 'string'
+        }
+    }
+
+    /**
+     * Calls a server-side event from browser or client. Use 'call' to call server from server
      *
      * @template Arguments - An array of argument types to be passed to the server event
-     * @template EventName - A string representing the server event name or union of names
+     * @template EventName - A string or union representing the server event name
+     *
+     * @param {EventName} eventName - The name of the server event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the server event
+     * @returns {void}
+     *
+     * @example
+     * // Calls an event on a server
+     * callServer<[], string, object>('onDataRequest')
+     */
+    public callServer<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+    >(eventName: EventName, args?: Arguments): void {
+        this.log('callServer', eventName, args)
+        if (this.forceBrowserDevMode_) return
+        Utils.errorUnknownEnvironment(this.environment_)
+
+        const state: RPCState = {
+            uuid: Utils.generateUUID(),
+            eventName,
+            calledTo: Environment.SERVER,
+            calledFrom: this.environment_,
+            knownError: undefined,
+            data: args,
+            type: RPCEventType.EVENT,
+        }
+
+        const dataRaw = Utils.prepareTransfer(state)
+
+        switch (this.environment_) {
+            case Environment.SERVER:
+                this.callSelf(state)
+                break
+
+            case Environment.CLIENT:
+                mp.events.callRemote(Events.LOCAL_EVENT_LISTENER, dataRaw)
+                break
+
+            case Environment.BROWSER:
+                mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
+                break
+        }
+    }
+
+    /**
+     * Calls an asynchronous server-side event from browser or client, expecting a response. Use 'callAsync' to call server from server
+     *
+     * @template Arguments - An array of argument types to be passed to the server event
+     * @template EventName - A string or union representing the server event name
      * @template Return - The type of the value returned by the server event
      *
      * @param {EventName} eventName - The name of the server event to be called
@@ -273,17 +452,17 @@ class Rpc extends Wrapper {
      * @returns {Promise<Return>} A promise resolving to the return value of the server event
      *
      * @example
-     * // Calls an event on server
+     * // Calls an event on a server
      * callServer<[], string, object>('onDataRequest').then(response => {
      *   console.log(`Received: ${response}`) //             ^ object
      * })
      */
-    public async callServer<
+    public async callServerAsync<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
         Return = unknown,
     >(eventName: EventName, args?: Arguments): Promise<Return> {
-        this.log('callServer', eventName, args)
+        this.log('callServerAsync', eventName, args)
         if (this.forceBrowserDevMode_)
             return undefined as unknown as Promise<Return>
         Utils.errorUnknownEnvironment(this.environment_)
@@ -302,7 +481,7 @@ class Rpc extends Wrapper {
 
         switch (this.environment_) {
             case Environment.SERVER:
-                return this.callSelf(state)
+                return this.callSelfAsync(state)
 
             case Environment.CLIENT:
                 mp.events.callRemote(Events.LOCAL_EVENT_LISTENER, dataRaw)
@@ -313,14 +492,122 @@ class Rpc extends Wrapper {
                 break
         }
 
-        return (await this.responseHandler(state.uuid)).data
+        return await this.responseHandler(state.uuid)
+            .then(r => r.data)
+            .catch((e: string) => {
+                state.knownError = e
+                return this.triggerError_(state)
+            })
     }
 
     /**
-     * Calls a browser-side event from server or client
+     * Calls a browser-side event from client or server. Use 'call' to call browser from browser
+     *
+     * @template Arguments - An array of argument types to be passed to the browser event
+     * @template EventName - A string or union representing the browser event name
+     *
+     * @param {EventName} eventName - The name of the browser event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the browser event
+     * @returns {void}
+     *
+     * @example
+     * // Calls an event on a browser without specifying a player
+     * callBrowser<[], string, object>('onDataRequest')
+     */
+    public callBrowser<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+    >(eventName: EventName, args?: Arguments): void
+    /**
+     * Calls a browser-side event from client or server. Use 'call' to call browser from browser
      *
      * @template Arguments - An array of argument types to be passed to the browser event
      * @template EventName - A string representing the browser event name or union of names
+     *
+     * @param {PlayerMp} player - The player for whom the browser event is called
+     * @param {EventName} eventName - The name of the browser event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the browser event
+     * @returns {void}
+     *
+     * @example
+     * // Calls an event on a browser for a specific player
+     * callBrowser<[string, number], string, boolean>(player, 'onPlayerAction', ['jump', 2])
+     */
+    public callBrowser<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+    >(player: PlayerMp, eventName: EventName, args?: Arguments): void
+    public callBrowser(
+        playerOrEventName: PlayerMp | string,
+        eventNameOrArgs?: string | unknown[],
+        args?: unknown[],
+    ) {
+        if (_is1StParamPlayer(playerOrEventName)) {
+            this.log(
+                'callBrowser',
+                eventNameOrArgs as string,
+                playerOrEventName,
+                eventNameOrArgs,
+                args,
+            )
+        } else {
+            this.log(
+                'callBrowser',
+                playerOrEventName as string,
+                eventNameOrArgs,
+            )
+        }
+
+        if (this.forceBrowserDevMode_) return
+        Utils.errorUnknownEnvironment(this.environment_)
+
+        const state: RPCState = {
+            uuid: Utils.generateUUID(),
+            eventName: !_is1StParamPlayer(playerOrEventName)
+                ? playerOrEventName
+                : _is2NdParamEventName(eventNameOrArgs)
+                  ? eventNameOrArgs
+                  : '',
+            calledTo: Environment.BROWSER,
+            calledFrom: this.environment_,
+            knownError: undefined,
+            data: _is1StParamPlayer(playerOrEventName) ? args : eventNameOrArgs,
+            type: RPCEventType.EVENT,
+        }
+
+        const dataRaw = Utils.prepareTransfer(state)
+
+        switch (this.environment_) {
+            case Environment.BROWSER:
+                this.callSelf(state)
+                break
+
+            case Environment.CLIENT:
+                mp.events.callRemote(Events.LOCAL_EVENT_LISTENER, dataRaw)
+                break
+
+            case Environment.SERVER:
+                ;(playerOrEventName as PlayerMp).call(
+                    Events.LOCAL_EVENT_LISTENER,
+                    [dataRaw],
+                )
+                break
+        }
+
+        function _is1StParamPlayer(x: unknown): x is PlayerMp {
+            return typeof x === 'object'
+        }
+
+        function _is2NdParamEventName(x: unknown): x is string {
+            return typeof x === 'string'
+        }
+    }
+
+    /**
+     * Calls an asynchronous browser-side event from client or server, expecting response. Use 'callAsync' to call browser from browser
+     *
+     * @template Arguments - An array of argument types to be passed to the browser event
+     * @template EventName - A string or union representing the browser event name
      * @template Return - The type of the value returned by the browser event
      *
      * @param {EventName} eventName - The name of the browser event to be called
@@ -328,18 +615,18 @@ class Rpc extends Wrapper {
      * @returns {Promise<Return>} A promise resolving to the return value of the browser event
      *
      * @example
-     * // Calls an event on browser without specifying a player
+     * // Calls an event on a browser without specifying a player
      * callBrowser<[], string, object>('onDataRequest').then(response => {
      *   console.log(`Received: ${response}`) //             ^ object
      * })
      */
-    public async callBrowser<
+    public async callBrowserAsync<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
         Return = unknown,
     >(eventName: EventName, args?: Arguments): Promise<Return>
     /**
-     * Calls a browser-side event from server or client
+     * Calls an asynchronous browser-side event from client or server, expecting response. Use 'callAsync' to call browser from browser
      *
      * @template Arguments - An array of argument types to be passed to the browser event
      * @template EventName - A string representing the browser event name or union of names
@@ -351,24 +638,24 @@ class Rpc extends Wrapper {
      * @returns {Promise<Return>} A promise resolving to the return value of the browser event
      *
      * @example
-     * // Calls an event on a browser for a specific player
+     * // Calls an asynchronous event on a browser for a specific player
      * callBrowser<[string, number], string, boolean>(player, 'onPlayerAction', ['jump', 2]).then(result => {
      *   console.log(`Action success: ${result}`) //                                              ^ boolean
      * })
      */
-    public async callBrowser<
+    public async callBrowserAsync<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
         Return = unknown,
     >(player: PlayerMp, eventName: EventName, args?: Arguments): Promise<Return>
-    public async callBrowser(
+    public async callBrowserAsync(
         playerOrEventName: PlayerMp | string,
         eventNameOrArgs?: string | unknown[],
         args?: unknown[],
     ) {
         if (_is1StParamPlayer(playerOrEventName)) {
             this.log(
-                'DEV callClient',
+                'callBrowserAsync',
                 eventNameOrArgs as string,
                 playerOrEventName,
                 eventNameOrArgs,
@@ -376,7 +663,7 @@ class Rpc extends Wrapper {
             )
         } else {
             this.log(
-                'DEV callClient',
+                'callBrowserAsync',
                 playerOrEventName as string,
                 eventNameOrArgs,
             )
@@ -417,7 +704,12 @@ class Rpc extends Wrapper {
                 break
         }
 
-        return (await this.responseHandler(state.uuid)).data
+        return await this.responseHandler(state.uuid)
+            .then(r => r.data)
+            .catch((e: string) => {
+                state.knownError = e
+                return this.triggerError_(state)
+            })
 
         function _is1StParamPlayer(x: unknown): x is PlayerMp {
             return typeof x === 'object'
@@ -432,7 +724,42 @@ class Rpc extends Wrapper {
      * Calls an event in current environment
      *
      * @template Arguments - An array of argument types to be passed to the event
-     * @template EventName - A string representing the event name or union of names
+     * @template EventName - A string or union representing the event name
+     *
+     * @param {EventName} eventName - The name of the event to be called
+     * @param {Arguments} [args] - Optional arguments to pass to the event
+     * @returns {void}
+     *
+     * @example
+     * // Calls an event in current environment
+     * call<[], string>('getSomething')
+     */
+    public call<
+        Arguments extends unknown[] = unknown[],
+        EventName extends string = string,
+    >(eventName: EventName, args?: Arguments): void {
+        this.log('call', eventName, args)
+        if (this.forceBrowserDevMode_) return
+        Utils.errorUnknownEnvironment(this.environment_)
+
+        const state: RPCState = {
+            uuid: Utils.generateUUID(),
+            eventName,
+            calledTo: this.environment_,
+            calledFrom: this.environment_,
+            knownError: undefined,
+            data: args,
+            type: RPCEventType.EVENT,
+        }
+
+        this.callSelf(state)
+    }
+
+    /**
+     * Calls an asynchronous event in current environment, expecting a response
+     *
+     * @template Arguments - An array of argument types to be passed to the event
+     * @template EventName - A string or union representing the event name
      * @template Return - The type of the value returned by the event
      *
      * @param {EventName} eventName - The name of the event to be called
@@ -445,12 +772,12 @@ class Rpc extends Wrapper {
      *   console.log(`Received: ${response}`) //      ^ number
      * })
      */
-    public async call<
+    public async callAsync<
         Arguments extends unknown[] = unknown[],
         EventName extends string = string,
         Return = unknown,
     >(eventName: EventName, args?: Arguments): Promise<Return> {
-        this.log('call', eventName, args)
+        this.log('callAsync', eventName, args)
         if (this.forceBrowserDevMode_)
             return undefined as unknown as Promise<Return>
         Utils.errorUnknownEnvironment(this.environment_)
@@ -465,13 +792,27 @@ class Rpc extends Wrapper {
             type: RPCEventType.EVENT,
         }
 
-        return await this.callSelf<Return>(state)
+        return await this.callSelfAsync<Return>(state)
     }
 
     /**
      * redirects an event in cases of it calling its own environment
      */
-    private async callSelf<Return = unknown>(state: RPCState): Promise<Return> {
+    private callSelf(state: RPCState): void {
+        state = this.verifyEvent_(state)
+        if (state.knownError) {
+            this.triggerError_(state, state.knownError)
+        }
+
+        this.state_[state.eventName](...state.data)
+    }
+
+    /**
+     * redirects an asynchronous event in cases of it calling its own environment
+     */
+    private async callSelfAsync<Return = unknown>(
+        state: RPCState,
+    ): Promise<Return> {
         state = this.verifyEvent_(state)
         if (state.knownError) {
             this.triggerError_(state, state.knownError)

rpc/src/server.ts

@@ -1,3 +1,5 @@
+/// <reference types="@ragempcommunity/types-server" />
+
 import { Wrapper } from './wrapper'
 import {
     type PlayerMp,

rpc/tsconfig.json

@@ -12,7 +12,7 @@
     "sourceMap": true,
   },
   "include": [
-    "./index.d.ts"
+    "src"
   ],
   "extends": ["../tsconfig.ragefw.json"]
 }

server/package.json

@@ -13,6 +13,7 @@
     ".": "./src/index.ts"
   },
   "publishConfig": {
+    "access": "public",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {

server/src/core/logger.ts

@@ -3,9 +3,9 @@ import winston, { format } from 'winston'
 const { timestamp, printf, colorize } = format
 
 /** Used to log in a server console */
-export class Logger {
+export class FW_Logger {
     private format = printf(({ message, level }) => {
-        return `[${new Date().toLocaleTimeString()}] [${level}]: ${message}`
+        return `[${new Date().toLocaleTimeString(undefined, { hour: 'numeric', minute: 'numeric', second: 'numeric', fractionalSecondDigits: 2 })}] [${level}]: ${message}`
     })
 
     private systemLogger = winston.createLogger({

server/src/core/middleware.ts

@@ -1,12 +1,12 @@
 import type * as T from '../types'
 
-export class Middleware {
+export class FW_Middleware {
     constructor() {}
 
-    private static async execute<EventName extends T.RageFW_ServerEvent>(
+    private static async execute<EventName extends T.FW_ServerEvent>(
-        middlewares: T.RageFW_MiddlewareFunction<EventName>[],
+        middlewares: T.FW_MiddlewareFunction<EventName>[],
-        args: T.RageFW_ServerArgs<EventName>,
+        args: T.FW_ServerArgs<EventName>,
-    ): Promise<T.RageFW_MiddlewareResponseInternal> {
+    ): Promise<T.FW_MiddlewareResponseInternal> {
         for (let i = 0; i < middlewares.length; i++) {
             const result = await middlewares[i](...args)
 
@@ -21,20 +21,20 @@ export class Middleware {
         }
     }
 
-    public static async process<EventName extends T.RageFW_ServerEvent>(
+    public static async process<EventName extends T.FW_ServerEvent>(
-        middlewareOptions: T.RageFW_MiddlewareOptions<EventName>,
+        middlewareOptions: T.FW_MiddlewareOptions<EventName>,
-        callback: T.RageFW_ServerCallback<EventName>,
+        callback: T.FW_ServerCallback<EventName>,
-        args: T.RageFW_ServerArgs<EventName>,
+        args: T.FW_ServerArgs<EventName>,
     ) {
         if (Array.isArray(middlewareOptions)) {
-            const middlewaresResponse = await Middleware.execute(
+            const middlewaresResponse = await FW_Middleware.execute(
                 middlewareOptions,
                 args,
             )
 
             if (middlewaresResponse.success) return await callback(...args)
         } else {
-            const middlewaresResponse = await Middleware.execute(
+            const middlewaresResponse = await FW_Middleware.execute(
                 middlewareOptions.executables,
                 args,
             )

server/src/core/player.ts

@@ -2,15 +2,45 @@ import { rpc } from './rpc'
 import type * as T from '../types'
 
 /** Handles event manipulations that require player to be present in context */
-export class Player {
+export class FW_Player {
     /**
-     * Triggers a client event from the server with arguments from shared types
+     * Triggers a client event from the server with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callClient`` or ``emitClient``
      *
      * @param {PlayerMp} player - Player object as an event target
      * @param eventName - The name of the client event to trigger
      * @param [args] - Arguments for the client event, if present
+     * @returns {void}
+     *
+     * @example
+     * // Triggering a client event without arguments
+     * fw.player.triggerClient("clientEventName")
+     *
+     * @example
+     * // Triggering a client event with arguments
+     * fw.player.triggerClient("clientEventName", ["message to client"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public triggerClient<EventName extends T.FW_ClientEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: T._ClientEventHasArgs<EventName> extends true
+            ? [T.FW_ClientArgs<EventName>]
+            : []
+    ): void {
+        rpc.callClient<typeof args, EventName>(player, eventName, args)
+    }
+
+    /**
+     * Triggers an asynchronous client event from the server with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callClientAsync`` or ``emitClientAsync``
+     *
+     * @param {PlayerMp} player - Player object as an event target
+     * @param eventName - The name of the client event to trigger
+     * @param [args] - Arguments for the client event, if present
      * @returns {Promise} resolving to the client's response for the event
      *
      * @example
@@ -23,25 +53,29 @@ export class Player {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerClient<EventName extends T.RageFW_ClientEvent>(
+    public async triggerClientAsync<EventName extends T.FW_ClientEvent>(
         player: PlayerMp,
         eventName: EventName,
         ...args: T._ClientEventHasArgs<EventName> extends true
-            ? [T.RageFW_ClientArgs<EventName>]
+            ? [T.FW_ClientArgs<EventName>]
             : []
-    ): Promise<T.RageFW_ClientReturn<EventName>> {
+    ): Promise<T.FW_ClientReturn<EventName>> {
-        return await rpc.callClient(player, eventName, args)
+        return await rpc.callClientAsync<
+            typeof args,
+            EventName,
+            T.FW_ClientReturn<EventName>
+        >(player, eventName, args)
     }
 
     /**
-     * Triggers a browser event from the server with arguments from shared types
+     * Triggers a browser event from the server with arguments from 'rage-fw-shared-types'
      *
      * Formerly known as ``callBrowser`` or ``emitBrowser``
      *
      * @param {PlayerMp} player - Player object as an event target
      * @param eventName - The name of the browser event to trigger
      * @param [args] - Arguments for the browser event, if present
-     * @returns {Promise} resolving to the browser's response for the event
+     * @returns {void}
      *
      * @example
      * // Triggering a browser event without arguments
@@ -53,16 +87,47 @@ export class Player {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public async triggerBrowser<EventName extends T.RageFW_BrowserEvent>(
+    public triggerBrowser<EventName extends T.FW_BrowserEvent>(
         player: PlayerMp,
         eventName: EventName,
         ...args: T._BrowserEventHasArgs<EventName> extends true
-            ? [T.RageFW_BrowserArgs<EventName>]
+            ? [T.FW_BrowserArgs<EventName>]
             : []
-    ): Promise<T.RageFW_BrowserReturn<EventName>> {
+    ): void {
-        return await rpc.callBrowser(player, eventName, args)
+        rpc.callBrowser<typeof args, EventName>(player, eventName, args)
-    }
     }
 
-// new Player().triggerBrowser({} as PlayerMp, 'customCefEvent', ['', 1])
+    /**
-// new Player().triggerClient({} as PlayerMp, 'customClientEvent', ['', 1])
+     * Triggers an asynchronous browser event from the server with arguments from 'rage-fw-shared-types', and expects to receive a response from an event
+     *
+     * Formerly known as ``callBrowserAsync`` or ``emitBrowserAsync``
+     *
+     * @param {PlayerMp} player - Player object as an event target
+     * @param eventName - The name of the browser event to trigger
+     * @param [args] - Arguments for the browser event, if present
+     * @returns {Promise} resolving to the browser's response for the event
+     *
+     * @example
+     * // Triggering a browser event without arguments
+     * fw.player.triggerBrowserAsync("browserEventName")
+     *
+     * @example
+     * // Triggering a browser event with arguments
+     * fw.player.triggerBrowserAsync("browserEventName", ["message to browser"])
+     *
+     * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
+     */
+    public async triggerBrowserAsync<EventName extends T.FW_BrowserEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: T._BrowserEventHasArgs<EventName> extends true
+            ? [T.FW_BrowserArgs<EventName>]
+            : []
+    ): Promise<T.FW_BrowserReturn<EventName>> {
+        return await rpc.callBrowserAsync<
+            typeof args,
+            EventName,
+            T.FW_BrowserReturn<EventName>
+        >(player, eventName, args)
+    }
+}

server/src/core/server.ts

@@ -1,9 +1,9 @@
 import { rpc } from './rpc'
-import { Middleware } from './middleware'
+import { FW_Middleware } from './middleware'
 import type * as T from '../types'
 
 /** Server-side interactions */
-export class Server {
+export class FW_Server {
     /**
      * Registers a server event with an associated callback
      *
@@ -11,7 +11,7 @@ export class Server {
      * @param callback - The callback function to be executed when the event is triggered
      * @param [options] - Optional settings for callback execution
      * @param [options.middlewares] - Middleware functions to be checked before the callback executes
-     * @returns {Server} The current server instance, enabling method chaining
+     * @returns {FW_Server} The current server instance, enabling method chaining
      *
      * @example
      * // Registering an event
@@ -40,13 +40,13 @@ export class Server {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public register<EventName extends T.RageFW_ServerEvent>(
+    public register<EventName extends T.FW_ServerEvent>(
         eventName: EventName,
-        callback: T.RageFW_ServerCallback<EventName>,
+        callback: T.FW_ServerCallback<EventName>,
         options?: {
-            middlewares?: T.RageFW_MiddlewareOptions<EventName>
+            middlewares?: T.FW_MiddlewareOptions<EventName>
         },
-    ): Server {
+    ): FW_Server {
         rpc.register<
             Parameters<typeof callback>,
             ReturnType<typeof callback> | Promise<unknown>,
@@ -54,7 +54,7 @@ export class Server {
         >(eventName, async (...data) => {
             if (!options?.middlewares) return await callback(...data)
 
-            await Middleware.process(options.middlewares, callback, data)
+            await FW_Middleware.process(options.middlewares, callback, data)
         })
 
         return this
@@ -64,7 +64,7 @@ export class Server {
      * Unregisters a server event, removing the associated callback
      *
      * @param eventName - The name of the event to unregister
-     * @returns {Server} The current server instance, enabling method chaining
+     * @returns {FW_Server} The current server instance, enabling method chaining
      *
      * @example
      * // Unregistering an event
@@ -72,25 +72,21 @@ export class Server {
      *
      * @see {@link https://git.entityseven.com/entityseven/rage-framework/wiki Wiki}
      */
-    public unregister<EventName extends T.RageFW_ServerEvent>(
+    public unregister<EventName extends T.FW_ServerEvent>(
         eventName: EventName,
-    ): Server {
+    ): FW_Server {
         rpc.unregister<EventName>(eventName)
 
         return this
     }
 
     // fixme
-    // public trigger<EventName extends keyof T.RageFW_ICustomServerEvent>(
+    // public trigger<EventName extends keyof T.FW_ICustomServerEvent>(
     //     eventName: EventName,
     //     ...args: T._ServerEventHasArgs<EventName> extends true
-    //         ? [T.RageFW_ServerArgs<EventName>]
+    //         ? [T.FW_ServerArgs<EventName>]
     //         : []
-    // ): Promise<T.RageFW_ServerReturn<EventName>> {
+    // ): Promise<T.FW_ServerReturn<EventName>> {
     //     return rpc.call(eventName, args)
     // }
 }
-
-// new Server()
-//     .register('customServerEvent', async (a, b, c) => true)
-//     .unregister('customServerEvent')

server/src/index.ts

@@ -1,6 +1,6 @@
-import { Logger, Player, Server, rpc } from './core'
+import { FW_Logger, FW_Player, FW_Server, rpc } from './core'
 
-export type { RageFW_MiddlewareFunction } from './types'
+export type { FW_MiddlewareFunction } from './types'
 
 /**
  * Package used on a server-side of your Rage:MP Server
@@ -9,13 +9,13 @@ export type { RageFW_MiddlewareFunction } from './types'
  */
 export const fw = {
     /** Server-side interactions */
-    event: new Server(),
+    event: new FW_Server(),
     /** Handles event manipulations that require player to be present in context */
-    player: new Player(),
+    player: new FW_Player(),
     /** Handles functions used to interact with the client environment */
     system: {
         /** Used to log in a server console */
-        log: new Logger(),
+        log: new FW_Logger(),
     },
     /** ``rage-fw-rpc`` instance used under the hood. It is highly recommended to use this one if you need it instead of creating a new instance */
     rpc,

server/src/types/browser.ts

@@ -1,34 +1,34 @@
-import type { RageFW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available browser event names
  * These only include custom events
  */
-export type RageFW_BrowserEvent = keyof RageFW_ICustomBrowserEvent
+export type FW_BrowserEvent = keyof FW_ICustomBrowserEvent
 
 /**
  * Array of arguments of an event you pass as a generic
  * These only include custom events
  */
-export type RageFW_BrowserArgs<K extends RageFW_BrowserEvent> = Parameters<
+export type FW_BrowserArgs<K extends FW_BrowserEvent> = Parameters<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
 /**
  * Return type of event you pass as a generic
  * These only include custom events
  */
-export type RageFW_BrowserReturn<K extends RageFW_BrowserEvent> = ReturnType<
+export type FW_BrowserReturn<K extends FW_BrowserEvent> = ReturnType<
-    RageFW_ICustomBrowserEvent[K]
+    FW_ICustomBrowserEvent[K]
 >
 
 /**
  *
  */
 export type _BrowserEventHasArgs<
-    EventName extends keyof RageFW_ICustomBrowserEvent,
+    EventName extends keyof FW_ICustomBrowserEvent,
-> = keyof RageFW_ICustomBrowserEvent extends never
+> = keyof FW_ICustomBrowserEvent extends never
     ? false
-    : Parameters<RageFW_ICustomBrowserEvent[EventName]>[0] extends undefined
+    : Parameters<FW_ICustomBrowserEvent[EventName]>[0] extends undefined
       ? false
       : true

server/src/types/client.ts

@@ -1,38 +1,35 @@
 /// <reference types="@ragempcommunity/types-server" />
 
-import type { RageFW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
+import type { FW_ICustomClientEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available client event names
  * These only include custom events
  */
-export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
+export type FW_ClientEvent = keyof FW_ICustomClientEvent
 
 /**
  * Array of arguments of an event you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
+export type FW_ClientArgs<K extends FW_ClientEvent> = K extends FW_ClientEvent
-    K extends RageFW_ClientEvent
+    ? Parameters<FW_ICustomClientEvent[K]>
-        ? Parameters<RageFW_ICustomClientEvent[K]>
     : never
 
 /**
  * Return type of event you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
+export type FW_ClientReturn<K extends FW_ClientEvent> = K extends FW_ClientEvent
-    K extends RageFW_ClientEvent
+    ? ReturnType<FW_ICustomClientEvent[K]>
-        ? ReturnType<RageFW_ICustomClientEvent[K]>
     : never
 
 /**
  *
  */
-export type _ClientEventHasArgs<
+export type _ClientEventHasArgs<EventName extends keyof FW_ICustomClientEvent> =
-    EventName extends keyof RageFW_ICustomClientEvent,
+    keyof FW_ICustomClientEvent extends never
-> = keyof RageFW_ICustomClientEvent extends never
         ? false
-    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+        : Parameters<FW_ICustomClientEvent[EventName]>[0] extends undefined
           ? false
           : true

server/src/types/index.ts

@@ -1,4 +1,4 @@
-export * from './browser'
+export type * from './browser'
-export * from './client'
+export type * from './client'
-export * from './middleware'
+export type * from './middleware'
-export * from './server'
+export type * from './server'

server/src/types/middleware.ts

@@ -1,26 +1,25 @@
 import type * as T from './server'
 
-export type RageFW_MiddlewareResponse =
+export type FW_MiddlewareResponse =
     | {
           success: boolean
           message?: string
       }
     | boolean
 
-export type RageFW_MiddlewareResponseInternal = {
+export type FW_MiddlewareResponseInternal = {
     success: boolean
     message?: string
     id?: number
 }
 
-export type RageFW_MiddlewareFunction<EventName extends T.RageFW_ServerEvent> =
+export type FW_MiddlewareFunction<EventName extends T.FW_ServerEvent> = (
-    (
+    ...args: T.FW_ServerArgs<EventName>
-        ...args: T.RageFW_ServerArgs<EventName>
+) => Promise<FW_MiddlewareResponse>
-    ) => Promise<RageFW_MiddlewareResponse>
 
-export type RageFW_MiddlewareOptions<EventName extends T.RageFW_ServerEvent> =
+export type FW_MiddlewareOptions<EventName extends T.FW_ServerEvent> =
-    | RageFW_MiddlewareFunction<EventName>[]
+    | FW_MiddlewareFunction<EventName>[]
     | {
-          executables: RageFW_MiddlewareFunction<EventName>[]
+          executables: FW_MiddlewareFunction<EventName>[]
           onError: (error: string) => unknown
       }

server/src/types/server.ts

@@ -1,27 +1,25 @@
 /// <reference types="@ragempcommunity/types-server" />
 
 import type {
-    RageFW_ICustomClientEvent,
+    FW_ICustomClientEvent,
-    RageFW_ICustomServerEvent,
+    FW_ICustomServerEvent,
 } from '@entityseven/rage-fw-shared-types'
 
-export type { RageFW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
+export type { FW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
 
 /**
  * Union of all available server event names
  * These also include system events
  */
-export type RageFW_ServerEvent =
+export type FW_ServerEvent = keyof FW_ICustomServerEvent | keyof IServerEvents
-    | keyof RageFW_ICustomServerEvent
-    | keyof IServerEvents
 
 /**
  * Array of arguments for an event, name of which you pass as a generic
  * These also include system events
  */
-export type RageFW_ServerArgs<K extends RageFW_ServerEvent> =
+export type FW_ServerArgs<K extends FW_ServerEvent> =
-    K extends keyof RageFW_ICustomServerEvent
+    K extends keyof FW_ICustomServerEvent
-        ? [PlayerMp, ...Parameters<RageFW_ICustomServerEvent[K]>]
+        ? [PlayerMp, ...Parameters<FW_ICustomServerEvent[K]>]
         : K extends keyof IServerEvents
           ? [PlayerMp, Parameters<IServerEvents[K]>]
           : never
@@ -30,9 +28,9 @@ export type RageFW_ServerArgs<K extends RageFW_ServerEvent> =
  * Return type for an event, name of which you pass as a generic
  * These include system and custom events
  */
-export type RageFW_ServerReturn<K extends RageFW_ServerEvent> =
+export type FW_ServerReturn<K extends FW_ServerEvent> =
-    K extends keyof RageFW_ICustomServerEvent
+    K extends keyof FW_ICustomServerEvent
-        ? ReturnType<RageFW_ICustomServerEvent[K]>
+        ? ReturnType<FW_ICustomServerEvent[K]>
         : K extends keyof IServerEvents
           ? ReturnType<IServerEvents[K]>
           : void
@@ -41,20 +39,18 @@ export type RageFW_ServerReturn<K extends RageFW_ServerEvent> =
  * Callback (function) for an event, name of which you pass as a generic
  * These include system and custom events
  */
-export type RageFW_ServerCallback<K extends RageFW_ServerEvent> = (
+export type FW_ServerCallback<K extends FW_ServerEvent> = (
-    ...args: RageFW_ServerArgs<K>
+    ...args: FW_ServerArgs<K>
-) => Promise<RageFW_ServerReturn<K>>
+) => Promise<FW_ServerReturn<K>>
 
 /**
  *
  */
-export type _ServerEventHasArgs<EventName extends RageFW_ServerEvent> =
+export type _ServerEventHasArgs<EventName extends FW_ServerEvent> =
-    EventName extends keyof RageFW_ICustomServerEvent
+    EventName extends keyof FW_ICustomServerEvent
-        ? keyof RageFW_ICustomClientEvent extends never
+        ? keyof FW_ICustomClientEvent extends never
             ? false
-            : Parameters<
+            : Parameters<FW_ICustomServerEvent[EventName]>[0] extends undefined
-                    RageFW_ICustomServerEvent[EventName]
-                >[0] extends undefined
               ? false
               : true
         : EventName extends keyof IServerEvents

shared-types/types/types/index.d.ts

@@ -1,14 +1,13 @@
 declare module '@entityseven/rage-fw-shared-types' {
-    export interface RageFW_ICustomServerEvent {
+    export interface FW_ICustomServerEvent {
-        customServerEvent(arg1: string, arg2: number): boolean
+        // customServerEvent(arg1: string, arg2: number): boolean // example event
     }
 
-    export interface RageFW_ICustomClientEvent {
+    export interface FW_ICustomClientEvent {
-        cefReady(): void
+        // customClientEvent(arg1: string, arg2: number): boolean // example event
-        customClientEvent(arg1: string, arg2: number): boolean
     }
 
-    export interface RageFW_ICustomBrowserEvent {
+    export interface FW_ICustomBrowserEvent {
-        customCefEvent(arg1: string, arg2: number): boolean
+        // customCefEvent(arg1: string, arg2: number): boolean // example event
     }
 }