@cybermp/client-types 2.2.1 → 2.2.2

package/precomputed/local-storage.d.ts

@@ -1,9 +1,37 @@
+/**
+ * Interface providing access to persistent client-side key-value storage.
+ * Data saved here remains available across different game sessions and server reconnections.
+ */
 export interface MpLocalStorage {
+  /**
+   * Associates a string value with a specific key in the storage database.
+   * If the key already exists, its value will be overwritten.
+   * @param key - The unique identifier name for the storage entry.
+   * @param value - The plaintext string data payload to be stored.
+   */
   set(key: string, value: string): void;
+
+  /**
+   * Retrieves the stored string value associated with the specified key.
+   * @param key - The unique identifier name of the entry to fetch.
+   * @returns The stored string value, or an empty string/null if the key does not exist.
+   */
   get(key: string): string;
 
+  /**
+   * Permanently removes a specific key-value entry from the storage map.
+   * @param key - The unique identifier name of the entry to delete.
+   */
   delete(key: string): void;
+
+  /**
+   * Clears all keys and values currently held in this resource's local storage instance.
+   */
   deleteAll(): void;
 
+  /**
+   * Explicitly flushes the current state of the in-memory storage data down to the physical disk.
+   * Use this to ensure volatile data isn't lost if the game client unexpectedly crashes.
+   */
   save(): void;
 }

package/precomputed/meta.d.ts

@@ -1,18 +1,78 @@
+/**
+ * Interface managing cross-resource and synchronized state metadata across the network layer.
+ * Allows attaching arbitrary data structures to globals, specific players, the local player, or synchronized network entities.
+ */
 export interface MpMeta {
+  /**
+   * Sets a global metadata value accessible across the entire runtime environment.
+   * @param key - The unique identifier string for the metadata entry.
+   * @param value - The data payload to store (can be any serializable object or primitive).
+   * @param sync - Optional flag. If `true`, synchronizes this metadata across the network to all other clients.
+   */
   setGlobalMeta(key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Retrieves a global metadata value by its key.
+   * @template T - The expected type of the returned metadata value.
+   * @param key - The unique identifier string of the metadata entry to look up.
+   * @returns The stored global metadata value cast to type T, or undefined if it does not exist.
+   */
   getGlobalMeta<T = any>(key: string): T;
 
+  /**
+   * Assigns a metadata value to a specific remote player using their unique player network ID.
+   * @param playerId - The network identification integer of the target player.
+   * @param key - The unique identifier string for this player's metadata entry.
+   * @param value - The data payload to attach to the player.
+   * @param sync - Optional flag. If `true`, syncs this change to all other connected clients over the network.
+   */
   setPlayerMeta(
     playerId: number,
     key: string,
     value: any,
     sync?: boolean,
   ): void;
+
+  /**
+   * Retrieves a metadata value attached to a specific remote player.
+   * @template T - The expected type of the returned metadata value.
+   * @param playerId - The network identification integer of the target player.
+   * @param key - The unique identifier string of the player's metadata entry.
+   * @returns The stored metadata value cast to type T, or undefined if it does not exist.
+   */
   getPlayerMeta<T = any>(playerId: number, key: string): T;
 
+  /**
+   * Sets a metadata value restricted or assigned specifically to the local player instance.
+   * @param key - The unique identifier string for the local player's metadata entry.
+   * @param value - The data payload to store.
+   * @param sync - Optional flag. If `true`, relays this local metadata state out to the server and other clients.
+   */
   setLocalPlayerMeta(key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Retrieves a metadata value attached specifically to the local player instance.
+   * @template T - The expected type of the returned metadata value.
+   * @param key - The unique identifier string of the local player's metadata entry.
+   * @returns The stored metadata value cast to type T, or undefined if it does not exist.
+   */
   getLocalPlayerMeta<T = any>(key: string): T;
 
+  /**
+   * Attaches a metadata state payload to any synchronized network entity (e.g., vehicles, props, peds) using its network ID.
+   * @param netId - The network-assigned unique identifier tracking the target entity.
+   * @param key - The unique identifier string for the entity's metadata entry.
+   * @param value - The data payload to attach to the entity.
+   * @param sync - Optional flag. If `true`, synchronizes this entity metadata property to all clients tracking this object.
+   */
   setEntityMeta(netId: number, key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Retrieves a metadata value associated with a synchronized network entity.
+   * @template T - The expected type of the returned metadata value.
+   * @param netId - The network-assigned unique identifier tracking the target entity.
+   * @param key - The unique identifier string of the entity's metadata entry.
+   * @returns The stored metadata value cast to type T, or undefined if it does not exist.
+   */
   getEntityMeta<T = any>(netId: number, key: string): T;
 }

package/precomputed/mp.d.ts

@@ -1,7 +1,8 @@
-import type { MpGame } from '../out/game';
+import type { MpClasses, MpGlobals } from '../out/game';
 import type { MpCef } from './cef';
 import type { MpDiscord } from './discord';
 import type { MpEvents } from './events';
+import type { MpGame } from './game';
 import type { MpLocalStorage } from './local-storage';
 import type { MpMeta } from './meta';
 import type { MpVoiceChat } from './voice-chat';
@@ -9,48 +10,143 @@ import type { MpVoiceChat } from './voice-chat';
 type ServerVector3 = [number, number, number];
 type ServerVector4 = [number, number, number, number];
 
+/**
+ * The main client-side manager interface for CyberMP.
+ * Aggregates all core subsystems, network synchronization mappers, local entity spawning arrays, and launcher-level APIs.
+ */
 export interface MpClient {
-  game: MpGame;
+  /**
+   * Access interface for native game engines, classes, and global engine parameters.
+   */
+  game: MpGame & MpGlobals & MpClasses;
+
+  /**
+   * The client event communication system bridge.
+   */
   events: MpEvents;
+
+  /**
+   * Metadata state synchronization manager across entities and network profiles.
+   */
   meta: MpMeta;
+
+  /**
+   * Integrated structural client voice communication management interface.
+   */
   voiceChat: MpVoiceChat;
+
+  /**
+   * Controls and interfaces with the embedded Chromium Embedded Framework web views.
+   */
   cef: MpCef;
+
+  /**
+   * Provides access to Discord rich presence and authentications integration layers.
+   */
   discord: MpDiscord;
+
+  /**
+   * Provides access to local key-value data storage states spanning resource restarts.
+   */
   localStorage: MpLocalStorage;
 
+  /**
+   * Returns an array of game engine handling entities currently within the local player's streaming radius.
+   * @param objName - The engine pool target class filter type to look up.
+   * @returns An array containing the local runtime engine IDs matching the target pool.
+   */
   getStreamedPool(
     objName: 'CVehicle' | 'CPed' | 'CPickup' | 'CObject',
   ): number[];
+
+  /**
+   * Gets an array containing all active remote network players currently streaming inside the local user's zone.
+   * @returns An array of native game engine entity IDs.
+   */
   getStreamedPlayers(): number[];
 
   /**
-   * Mapping between network and game IDs.
+   * Resolves a network sync ID into its corresponding local native game engine entity reference handle for a vehicle.
+   * @param id - The unique synchronization network ID assigned by the server host.
+   * @returns The corresponding local native game engine vehicle handle ID.
    */
   getVehicleGameIdByNetworkId(id: number): number;
 
+  /**
+   * Resolves a network sync ID into its corresponding local native game engine entity reference handle for a player.
+   * @param id - The unique synchronization network ID assigned by the server host.
+   * @returns The corresponding local native game engine player handle ID.
+   */
   getPlayerGameIdByNetworkId(id: number): number;
 
+  /**
+   * Resolves a network sync ID into its corresponding local native game engine entity reference handle for a static object.
+   * @param id - The unique synchronization network ID assigned by the server host.
+   * @returns The corresponding local native game engine object handle ID.
+   */
   getObjectGameIdByNetworkId(id: number): number;
 
+  /**
+   * Translates a native vehicle game handle into its global shared replication network sync ID.
+   * @param hash - The local native game engine entity instance handle.
+   * @returns The synchronized network ID assigned to that vehicle.
+   */
   getVehicleNetworkIdByGameId(hash: number): number;
 
+  /**
+   * Translates a native player character entity handle into its global shared replication network sync ID.
+   * @param hash - The local native game engine entity instance handle.
+   * @returns The synchronized network ID assigned to that player.
+   */
   getPlayerNetworkIdByGameId(hash: number): number;
 
+  /**
+   * Translates a native object or entity prop handle into its global shared replication network sync ID.
+   * @param hash - The local native game engine entity instance handle.
+   * @returns The synchronized network ID assigned to that object.
+   */
   getObjectNetworkIdByGameId(hash: number): number;
 
+  /**
+   * Translates a native pedestrian/NPC handle into its global shared replication network sync ID.
+   * @param hash - The local native game engine entity instance handle.
+   * @returns The synchronized network ID assigned to that pedestrian.
+   */
   getPedNetworkIdByGameId(hash: number): number;
 
+  /**
+   * Resolves a network sync ID into its corresponding local native game engine entity reference handle for a pedestrian.
+   * @param id - The unique synchronization network ID assigned by the server host.
+   * @returns The corresponding local native game engine pedestrian handle ID.
+   */
   getPedGameIdByNetworkId(hash: number): number;
 
   /**
-   * Local player spawning API.
+   * Assigns the spawn coordinates and rotation tracking data for spawnLocalPlayer function.
+   * @param x - Horizontal grid position coordinate value.
+   * @param y - Vertical grid position coordinate value.
+   * @param z - Height grid elevation coordinate value.
+   * @param yaw - The horizontal rotation layout angle in degrees.
    */
   setSpawnDataLocalPlayer(x: number, y: number, z: number, yaw: number): void;
 
+  /**
+   * Spawns local player based on data setted by {@link setSpawnDataLocalPlayer}
+   * @returns `true` if the spawn lifecycle sequence initiated successfully, otherwise `false`.
+   */
   spawnLocalPlayer(): boolean;
 
   /**
-   * Spawn local-only entities (not synced).
+   * Instantiates a localized ped entity.
+   * This entity remains completely un-synchronized and invisible to other remote clients.
+   * @param skinHash - Asset model signature key hash.
+   * @param appHash - Visual appearance setup key components variation hash.
+   * @param x - Horizontal coordinate space.
+   * @param y - Vertical coordinate space.
+   * @param z - Elevation height space coordinate.
+   * @param yaw - Rotational alignment facing angle.
+   * @param streaming - Controls if engine virtualization automatically handles streaming boundaries tracking.
+   * @returns The resulting unique local game entity handle ID.
    */
   spawnLocalPed(
     skinHash: number | bigint,
@@ -62,6 +158,20 @@ export interface MpClient {
     streaming: boolean,
   ): number;
 
+  /**
+   * Instantiates a localized vehicle entity inside the engine environment.
+   * This entity remains completely un-synchronized and invisible to other remote clients.
+   * @param skinHash - Asset model signature key hash.
+   * @param appHash - Visual appearance setup key components variation hash.
+   * @param x - Horizontal coordinate space.
+   * @param y - Vertical coordinate space.
+   * @param z - Elevation height space coordinate.
+   * @param roll - Longitudinal rotation axis orientation angle.
+   * @param pitch - Lateral rotation axis orientation angle.
+   * @param yaw - Directional heading alignment angle.
+   * @param streaming - Controls if engine virtualization automatically handles streaming boundaries tracking.
+   * @returns The resulting unique local game entity handle ID.
+   */
   spawnLocalVehicle(
     skinHash: number | bigint,
     appHash: number | bigint,
@@ -74,6 +184,20 @@ export interface MpClient {
     streaming: boolean,
   ): number;
 
+  /**
+   * Instantiates a localized world object or dynamic prop entity inside the engine environment.
+   * This entity remains completely un-synchronized and invisible to other remote clients.
+   * @param skinHash - Asset model signature key hash.
+   * @param appHash - Visual appearance setup key components variation hash.
+   * @param x - Horizontal coordinate space.
+   * @param y - Vertical coordinate space.
+   * @param z - Elevation height space coordinate.
+   * @param roll - Longitudinal rotation axis orientation angle.
+   * @param pitch - Lateral rotation axis orientation angle.
+   * @param yaw - Directional heading alignment angle.
+   * @param streaming - Controls if engine virtualization automatically handles streaming boundaries tracking.
+   * @returns The resulting unique local game entity handle ID.
+   */
   spawnLocalObject(
     skinHash: bigint | number,
     appHash: bigint | number,
@@ -86,52 +210,96 @@ export interface MpClient {
     streaming: boolean,
   ): number;
 
+  /**
+   * Forces immediate engine de-allocation and cleanup deletion maps targeting an isolated local pedestrian.
+   * @param hash - Unique local game engine entity instance handle to clear.
+   */
   despawnLocalPed(hash: number): void;
 
+  /**
+   * Forces immediate engine de-allocation and cleanup deletion maps targeting an isolated local vehicle.
+   * @param hash - Unique local game engine entity instance handle to clear.
+   */
   despawnLocalVehicle(hash: number): void;
 
+  /**
+   * Forces immediate engine de-allocation and cleanup deletion maps targeting an isolated local object.
+   * @param hash - Unique local game engine entity instance handle to clear.
+   */
   despawnLocalObject(hash: number): void;
 
   /**
-   * Get Discord token via game SDK (unstable).
+   * Requests a secure Discord authentication OAuth2 user token via embedded client game SDK pathways.
+   * @deprecated This method is unstable and may cause engine synchronization pauses. Use {@link getDiscordCodeAuthorization} instead.
+   * @param discordAppId - The registered client registration application client ID string.
+   * @returns Token string payload containing user authorization tokens.
    */
   getDiscordOAuth2Token(discordAppId: string): string;
 
   /**
-   * Get Discord auth code (preferred).
+   * Requests a preferred secure authentication application code payload via Discord's authorization flow.
+   * @deprecated
+   * @param discordAppId - The registered client registration application client ID string.
+   * @param scopes - Separated validation permission request keyword groups strings (e.g., `"identify guilds"`).
+   * @returns An authentication code string convertible into access tokens server-side.
    */
   getDiscordCodeAuthorization(discordAppId: string, scopes: string): string;
 
   /**
-   * Returns current server IP:PORT string.
+   * Returns the endpoint address configuration tracking string of the current server session.
+   * @returns Endpoint routing connection destination details string (e.g., `"127.0.0.1:4430"`).
    */
   getCurrentServerEndpoint(): string;
 
   /**
-   * Get server ID from player hash.
+   * Extracts the unique global player numeric index ID matching an active native local player entity handle.
+   * @param playerHash - The target local engine character object handle tracking number.
+   * @returns Network server-side entity tracking index ID number.
    */
   getPlayerServerId(playerHash: number): number;
 
   /**
-   * Get src variable value as string.
+   * Queries environment configuration arrays to fetch string system variable values defined inside config manifest structures.
+   * @param varName - Target environmental variable path identifier name key string.
+   * @returns The corresponding variable value matching that name string.
    */
   getVar(varName: string): string;
 
   /**
-   * Get console variable value as integer.
+   * Queries environment configuration arrays to fetch integer variable values defined inside config manifest structures.
+   * @param varName - Target environmental variable path identifier name key string.
+   * @returns The variable evaluation value parsed into a numerical integer.
    */
   getVarInt(varName: string): number;
 
   /**
-   * Returns time in ms since game start.
+   * Retrieves total execution duration elapsed since initialization of the master game engine shell layer tracking loops.
+   * @returns Calculated time tracker measurement value in milliseconds.
    */
   getGameTimer(): number;
 
+  /**
+   * Fetches raw unparsed configurations mapping platform launcher operational states.
+   * @returns Unparsed JSON payload string representing client settings configurations.
+   */
   getLauncherSettingsJSON(): string;
 
+  /**
+   * Fetches parsed layout profiles tracking core client options configurations.
+   * @returns Object tracking client properties choices.
+   */
   getLauncherSettings(): any;
 
+  /**
+   * Registers a callback execution function that runs continuously on every game engine render frame.
+   * @param cb - The logic routine executed on every render cycle.
+   * @returns An execution identifier handle index required to disable the execution loop later.
+   */
   setTick(cb: () => any): number;
 
+  /**
+   * Removes and unbinds an active rendering cycle tracking loop execution block.
+   * @param tickId - The original registration index key returned by {@link setTick}.
+   */
   clearTick(tickId: number): void;
 }

package/precomputed/voice-chat.d.ts

@@ -1,23 +1,86 @@
 import type * as CyberEnums from '../out/enums';
 
+/**
+ * Interface managing the integrated voice communication subsystem.
+ * Provides controls for device routing, audio leveling, capture thresholds, and distance-based 3D spatial attenuation.
+ */
 export interface MpVoiceChat {
+  /**
+   * Toggles the global operational state of the voice chat system.
+   * @param state - `true` to fully initialize and connect to the voice server channels, `false` to shut down capture and playback.
+   */
   enable(state: boolean): void;
 
+  /**
+   * Modifies how the local microphone capture is triggered (e.g., Continuous, Voice Activity, or Push-To-Talk).
+   * @param type - The target voice activation mode enumeration value.
+   */
   changeActivationType(type: CyberEnums.EVoiceActivationType): void;
+
+  /**
+   * Binds a specific hardware key code or input identifier to trigger microphone transmission when using Push-To-Talk.
+   * @param key - The numerical key code or explicit structural input key enum to assign.
+   */
   bindPushToTalkKey(key: number | CyberEnums.EInputKey): void;
 
+  /**
+   * Sets the master playback volume level for inbound remote voice streams.
+   * @param value - Volumetric multiplier factor (typically ranging from `0.0` for muted up to `1.0` or higher for boosted gain).
+   */
   setOutputVolume(value: number): void;
+
+  /**
+   * Adjusts the local recording gain modification layer applied to the hardware microphone input before network broadcasting.
+   * @param value - Volumetric multiplier factor (typically ranging from `0.0` to `1.0`).
+   */
   setInputVolume(value: number): void;
+
+  /**
+   * Sets the voice activity detection (VAD) audio floor threshold.
+   * Captured audio below this amplitude level will be automatically gated and ignored.
+   * @param value - The cutoff sensitivity threshold limit.
+   */
   setMicrophoneSensitivity(value: number): void;
 
+  /**
+   * Queries the system multimedia framework to retrieve descriptive text labels of all available physical audio output playback devices.
+   * @returns An array containing the plaintext names or driver descriptors of accessible output hardware components.
+   */
   getOutputDevices(): string[];
+
+  /**
+   * Queries the system multimedia framework to retrieve descriptive text labels of all available physical audio input recording devices.
+   * @returns An array containing the plaintext names or driver descriptors of accessible input hardware components.
+   */
   getInputDevices(): string[];
 
+  /**
+   * Routes the voice playback audio rendering stream into a specific physical output device using its indexed layout match.
+   * @param index - The hardware array element position index matching the list returned by {@link getOutputDevices}.
+   */
   setOutputDevice(index: number): void;
+
+  /**
+   * Selects and hooks the physical recording mic input stream into a specific hardware component using its indexed layout match.
+   * @param index - The hardware array element position index matching the list returned by {@link getInputDevices}.
+   */
   setInputDevice(index: number): void;
 
+  /**
+   * Configures the local input listening radius or proximity box boundaries.
+   * @param distance - Maximum distance measurement units used to bound transmission scopes.
+   */
   setInputDistance(distance: number): void;
+
+  /**
+   * Sets the maximum linear distance radius over which a remote player's 3D spatialized voice stream will attenuate down to silence.
+   * @param distance - Proximity spatial calculation distance limits.
+   */
   setOutputDistance(distance: number): void;
 
+  /**
+   * Evaluates whether the voice client manager is initialized, connected to a voice channel, and operating normally.
+   * @returns `true` if the system layer is running and ready, otherwise `false`.
+   */
   isActive(): boolean;
 }