@cybermp-community/client-types 2.5.1 → 2.5.3

package/dist/precomputed/local.ts

@@ -0,0 +1,103 @@
+/**
+ * Spawns the local player and creates client-only entities not visible to other players.
+ */
+export interface MpLocal {
+  /**
+   * Spawns the local player at the given world position.
+   * @param x - World X coordinate.
+   * @param y - World Y coordinate.
+   * @param z - World Z coordinate (height).
+   * @param yaw - Facing angle in degrees.
+   * @returns `true` on success, `false` otherwise.
+   */
+  spawnPlayer(x: number, y: number, z: number, yaw: number): boolean;
+
+  /**
+   * Creates a client-only ped at the given position. Not synced — invisible to other players.
+   * @param skinHash - Model hash.
+   * @param appHash - Appearance variant hash.
+   * @param x - World X coordinate.
+   * @param y - World Y coordinate.
+   * @param z - World Z coordinate.
+   * @param yaw - Facing angle.
+   * @param streaming - Whether the engine manages streaming boundaries automatically.
+   * @returns Local entity handle.
+   */
+  spawnPed(
+    skinHash: number | bigint,
+    appHash: number | bigint,
+    x: number,
+    y: number,
+    z: number,
+    yaw: number,
+    streaming: boolean,
+  ): number;
+
+  /**
+   * Creates a client-only vehicle at the given position. Not synced — invisible to other players.
+   * @param skinHash - Model hash.
+   * @param appHash - Appearance variant hash.
+   * @param x - World X coordinate.
+   * @param y - World Y coordinate.
+   * @param z - World Z coordinate.
+   * @param roll - Roll angle.
+   * @param pitch - Pitch angle.
+   * @param yaw - Yaw angle.
+   * @param streaming - Whether the engine manages streaming boundaries automatically.
+   * @returns Local entity handle.
+   */
+  spawnVehicle(
+    skinHash: number | bigint,
+    appHash: number | bigint,
+    x: number,
+    y: number,
+    z: number,
+    roll: number,
+    pitch: number,
+    yaw: number,
+    streaming: boolean,
+  ): number;
+
+  /**
+   * Creates a client-only prop or world object at the given position. Not synced — invisible to other players.
+   * @param skinHash - Model hash.
+   * @param appHash - Appearance variant hash.
+   * @param x - World X coordinate.
+   * @param y - World Y coordinate.
+   * @param z - World Z coordinate.
+   * @param roll - Roll angle.
+   * @param pitch - Pitch angle.
+   * @param yaw - Yaw angle.
+   * @param streaming - Whether the engine manages streaming boundaries automatically.
+   * @returns Local entity handle.
+   */
+  spawnObject(
+    skinHash: bigint | number,
+    appHash: bigint | number,
+    x: number,
+    y: number,
+    z: number,
+    roll: number,
+    pitch: number,
+    yaw: number,
+    streaming: boolean,
+  ): number;
+
+  /**
+   * Destroys a client-only ped and frees its engine resources.
+   * @param hash - Local entity handle returned by {@link spawnPed}.
+   */
+  despawnPed(hash: number): void;
+
+  /**
+   * Destroys a client-only vehicle and frees its engine resources.
+   * @param hash - Local entity handle returned by {@link spawnVehicle}.
+   */
+  despawnVehicle(hash: number): void;
+
+  /**
+   * Destroys a client-only object and frees its engine resources.
+   * @param hash - Local entity handle returned by {@link spawnObject}.
+   */
+  despawnObject(hash: number): void;
+}

package/dist/precomputed/meta.ts

@@ -1,18 +1,72 @@
+/**
+ * Read/write metadata on the global scope, specific players, or network entities, with optional network sync.
+ */
 export interface MpMeta {
+  /**
+   * Writes a value to the global metadata store.
+   * @param key - Metadata key.
+   * @param value - Any serializable value.
+   * @param sync - If `true`, the value is broadcast to all connected clients.
+   */
   setGlobalMeta(key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Reads a value from the global metadata store.
+   * @template T - Expected type of the value.
+   * @param key - Metadata key.
+   * @returns The stored value cast to `T`, or `undefined` if not set.
+   */
   getGlobalMeta<T = any>(key: string): T;
 
-  setPlayerMeta(
-    playerId: number,
-    key: string,
-    value: any,
-    sync?: boolean,
-  ): void;
+  /**
+   * Writes a metadata value to a specific remote player.
+   * @param playerId - Target player's network ID.
+   * @param key - Metadata key.
+   * @param value - Value to attach.
+   * @param sync - If `true`, the change is broadcast to all clients.
+   */
+  setPlayerMeta(playerId: number, key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Reads a metadata value from a specific remote player.
+   * @template T - Expected type of the value.
+   * @param playerId - Target player's network ID.
+   * @param key - Metadata key.
+   * @returns The stored value cast to `T`, or `undefined` if not set.
+   */
   getPlayerMeta<T = any>(playerId: number, key: string): T;
 
-  setLocalPlayerMeta(key: string, value: any): void;
+  /**
+   * Writes a metadata value to the local player.
+   * @param key - Metadata key.
+   * @param value - Value to store.
+   * @param sync - If `true`, the value is relayed to the server and other clients.
+   */
+  setLocalPlayerMeta(key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Reads a metadata value from the local player.
+   * @template T - Expected type of the value.
+   * @param key - Metadata key.
+   * @returns The stored value cast to `T`, or `undefined` if not set.
+   */
   getLocalPlayerMeta<T = any>(key: string): T;
 
+  /**
+   * Writes a metadata value to a synced network entity (vehicle, ped, object, etc.).
+   * @param netId - Network ID of the target entity.
+   * @param key - Metadata key.
+   * @param value - Value to attach.
+   * @param sync - If `true`, the value is broadcast to all clients tracking this entity.
+   */
   setEntityMeta(netId: number, key: string, value: any, sync?: boolean): void;
+
+  /**
+   * Reads a metadata value from a synced network entity.
+   * @template T - Expected type of the value.
+   * @param netId - Network ID of the target entity.
+   * @param key - Metadata key.
+   * @returns The stored value cast to `T`, or `undefined` if not set.
+   */
   getEntityMeta<T = any>(netId: number, key: string): T;
 }

package/dist/precomputed/mp.d.ts

@@ -2,135 +2,116 @@ import type { MpCef } from './cef.d.ts';
 import type { MpDiscord } from './discord.d.ts';
 import type { MpEvents } from './events/index.js';
 import type { MpLocalStorage } from './local-storage.d.ts';
+import type { MpNetwork } from './network';
 import type { MpMeta } from './meta.d.ts';
 import type { MpVoiceChat } from './voice-chat.d.ts';
 import type { MpExports } from './exports.d.ts';
+import type { MpLocal } from './local.d.ts';
+import type { MpResources } from './resources.js';
+import type { MpCommands } from './commands.js';
 
 declare module '../mp.d.ts' {
   export interface MpClient {
-    exports: MpExports;
+    /**
+     * Event bus for client, server, and CEF communication.
+     */
     events: MpEvents;
-    meta: MpMeta;
-    voiceChat: MpVoiceChat;
-    cef: MpCef;
-    discord: MpDiscord;
-    localStorage: MpLocalStorage;
-
-    getStreamedPool(
-      objName: 'CVehicle' | 'CPed' | 'CPickup' | 'CObject',
-    ): number[];
-    getStreamedPlayers(): number[];
 
     /**
-     * Mapping between network and game IDs.
+     * Metadata store for globals, players, and network entities.
      */
-    getVehicleGameIdByNetworkId(id: number): number;
-
-    getPlayerGameIdByNetworkId(id: number): number;
-
-    getObjectGameIdByNetworkId(id: number): number;
-
-    getVehicleNetworkIdByGameId(hash: number): number;
-
-    getPlayerNetworkIdByGameId(hash: number): number;
-
-    getObjectNetworkIdByGameId(hash: number): number;
-
-    getPedNetworkIdByGameId(hash: number): number;
-
-    getPedGameIdByNetworkId(hash: number): number;
+    meta: MpMeta;
 
     /**
-     * Local player spawning API.
+     * Voice chat controls and device management.
      */
-    setSpawnDataLocalPlayer(x: number, y: number, z: number, yaw: number): void;
-
-    spawnLocalPlayer(): boolean;
+    voiceChat: MpVoiceChat;
 
     /**
-     * Spawn local-only entities (not synced).
+     * CEF browser — focus, cursor, and URL control.
      */
-    spawnLocalPed(
-      skinHash: number,
-      appHash: number,
-      x: number,
-      y: number,
-      z: number,
-      yaw: number,
-      streaming: boolean,
-    ): number;
-
-    spawnLocalVehicle(
-      skinHash: number,
-      appHash: number,
-      x: number,
-      y: number,
-      z: number,
-      roll: number,
-      pitch: number,
-      yaw: number,
-      streaming: boolean,
-    ): number;
+    cef: MpCef;
 
-    spawnLocalObject(
-      skinHash: bigint | number,
-      appHash: bigint | number,
-      x: number,
-      y: number,
-      z: number,
-      roll: number,
-      pitch: number,
-      yaw: number,
-      streaming: boolean,
-    ): number;
+    /**
+     * Discord rich presence and OAuth2 integration.
+     */
+    discord: MpDiscord;
 
-    despawnLocalPed(hash: number): void;
+    /**
+     * Entity streaming and network-to-game-ID utilities.
+     */
+    network: MpNetwork;
 
-    despawnLocalVehicle(hash: number): void;
+    /**
+     * Spawning and despawning of the local player and client-only entities.
+     */
+    local: MpLocal;
 
-    despawnLocalObject(hash: number): void;
+    /**
+     * Registration and removal of client-side console commands.
+     */
+    commands: MpCommands;
 
     /**
-     * Get Discord token via game SDK (unstable).
+     * Persistent client-side key-value storage.
      */
-    getDiscordOAuth2Token(discordAppId: string): string;
+    localStorage: MpLocalStorage;
 
     /**
-     * Get Discord auth code (preferred).
+     * Cross-resource function exposure and invocation.
      */
-    getDiscordCodeAuthorization(discordAppId: string, scopes: string): string;
+    exports: MpExports;
 
     /**
-     * Returns current server IP:PORT string.
+     * Resource management, loading, and state tracking.
      */
-    getCurrentServerEndpoint(): string;
+    resources: MpResources;
 
     /**
-     * Get server ID from player hash.
+     * Returns the current server's IP:PORT string.
      */
-    getPlayerServerId(playerHash: number): number;
+    getCurrentServerEndpoint(): string;
 
     /**
-     * Get src variable value as string.
+     * Reads a string config variable from the launcher manifest.
+     * @param varName - Variable name.
+     * @returns The variable's string value.
      */
     getVar(varName: string): string;
 
     /**
-     * Get console variable value as integer.
+     * Reads an integer config variable from the launcher manifest.
+     * @param varName - Variable name.
+     * @returns The variable's value as an integer.
      */
     getVarInt(varName: string): number;
 
     /**
-     * Returns time in ms since game start.
+     * Returns elapsed time since the game engine started, in milliseconds.
      */
-    getTimer(): number;
+    getGameTimer(): number;
 
+    /**
+     * Returns the raw unparsed launcher settings as a JSON string.
+     */
     getLauncherSettingsJSON(): string;
 
+    /**
+     * Returns the parsed launcher settings object.
+     */
     getLauncherSettings(): any;
 
+    /**
+     * Registers a callback that runs on every game engine render frame.
+     * @param cb - The function to call each frame.
+     * @returns A tick ID used to cancel the loop with {@link clearTick}.
+     */
     setTick(cb: () => any): number;
 
+    /**
+     * Cancels a render-frame loop registered with {@link setTick}.
+     * @param tickId - The tick ID returned by {@link setTick}.
+     */
     clearTick(tickId: number): void;
   }
 }

package/dist/precomputed/network.ts

@@ -0,0 +1,79 @@
+/**
+ * Entity streaming queries and network-to-game-ID translation utilities.
+ */
+export interface MpNetwork {
+  /**
+   * Returns the current server's address string.
+   * @returns Connection endpoint, e.g. `"127.0.0.1:4430"`.
+   */
+  getServerAddress(): string;
+
+  /**
+   * Returns all engine entities of the given pool type within the local player's stream range.
+   * @param objName - Entity pool class to query.
+   * @returns Array of local game engine handles.
+   */
+  getStreamedPool(objName: 'CVehicle' | 'CPed' | 'CPickup' | 'CObject'): number[];
+
+  /**
+   * Returns all remote players currently within the local player's stream zone.
+   * @returns Array of native game engine entity IDs.
+   */
+  getStreamedPlayers(): number[];
+
+  /**
+   * Converts a vehicle's network ID to its local game engine handle.
+   * @param networkId - Server-assigned network ID.
+   * @returns Local game engine vehicle handle.
+   */
+  getVehicleGameId(networkId: number): number;
+
+  /**
+   * Converts a vehicle's local game engine handle to its network ID.
+   * @param gameId - Local game engine handle.
+   * @returns Network ID of the vehicle.
+   */
+  getVehicleId(gameId: number): number;
+
+  /**
+   * Converts a ped's local game engine handle to its network ID.
+   * @param gameId - Local game engine handle.
+   * @returns Network ID of the ped.
+   */
+  getPedId(gameId: number): number;
+
+  /**
+   * Converts a ped's network ID to its local game engine handle.
+   * @param networkId - Server-assigned network ID.
+   * @returns Local game engine ped handle.
+   */
+  getPedGameId(networkId: number): number;
+
+  /**
+   * Converts an object's network ID to its local game engine handle.
+   * @param networkId - Server-assigned network ID.
+   * @returns Local game engine object handle.
+   */
+  getObjectGameId(networkId: number): number;
+
+  /**
+   * Converts an object's local game engine handle to its network ID.
+   * @param gameId - Local game engine handle.
+   * @returns Network ID of the object.
+   */
+  getObjectId(gameId: number): number;
+
+  /**
+   * Converts a player's network ID to their local game engine handle.
+   * @param networkId - Server-assigned network ID.
+   * @returns Local game engine player handle.
+   */
+  getPlayerGameId(networkId: number): number;
+
+  /**
+   * Converts a player's local game engine handle to their network ID.
+   * @param gameId - Local game engine handle.
+   * @returns Network ID of the player.
+   */
+  getPlayerId(gameId: number): number;
+}

package/dist/precomputed/resources.d.ts

@@ -0,0 +1,64 @@
+import type * as CyberEnums from '../enums';
+
+/**
+ * Interface for managing, loading, and tracking resources.
+ *
+ * Provides utilities for reading configuration files (TOML), loading raw file contents,
+ * querying the lifecycle status of specific assets, and identifying the active resource container.
+ */
+export interface MpResources {
+  /**
+   * Retrieves the raw string contents of a specified TOML configuration file.
+   * @param name - The name or identifier key of the target TOML resource.
+   * @returns The raw TOML formatted configuration string.
+   */
+  getTOML(name: string): string;
+
+  /**
+   * Reads a file inside a resource and returns its contents.
+   * @param resourceName Name of the resource.
+   * @param pathToResource Path to the file.
+   * @returns File content as string.
+   */
+  loadFile(resourceName: string, pathToResource: string): string;
+
+  /**
+   * Queries the current loading or runtime execution state of a specific resource.
+   * @param name - The name of the target resource to check.
+   * @returns The current operational state enumeration value.
+   */
+  getState(name: string): CyberEnums.EResourceState;
+
+  /**
+   * Gets the name identifier of the current resource or script execution context.
+   * @returns The name string of the active resource bundle.
+   */
+  getCurrentName(): string;
+
+  /**
+   * Starts a specific resource by name.
+   * @param resourceName Name of the resource to start.
+   */
+  start(resourceName: string): void;
+
+  /**
+   * Stops a specific resource by name.
+   * @param resourceName Name of the resource to stop.
+   */
+  stop(resourceName: string): void;
+
+  /**
+   * Restarts a specific resource by name.
+   * @param resourceName Name of the resource to restart.
+   */
+  restart(resourceName: string): void;
+
+  /**
+   * Gets metadata from a resource manifest.
+   * @param resourceName Resource name.
+   * @param keyName Metadata key.
+   * @param index Index (if multiple values exist).
+   * @returns Metadata string.
+   */
+  getMetadata(resourceName: string, keyName: string, index: number): string;
+}

package/dist/precomputed/voice-chat.ts

@@ -3,25 +3,89 @@
 import * as CyberEnums from '../enums';
 
 export interface MpVoiceChat {
+  /**
+   * Enables or disables the voice chat system entirely.
+   * @param state - `true` to connect and start capture, `false` to shut down.
+   */
   enable(state: boolean): void;
 
+  /**
+   * Sets how the microphone is activated (continuous, voice activity, or push-to-talk).
+   * @param type - The desired activation mode.
+   */
   changeActivationType(type: CyberEnums.EVoiceActivationType): void;
+
+  /**
+   * Assigns a key to trigger microphone transmission in push-to-talk mode.
+   * @param key - Key code or input key enum value.
+   */
   bindPushToTalkKey(key: number | CyberEnums.EInputKey): void;
 
+  /**
+   * Sets the playback volume for incoming remote voice streams.
+   * @param value - Volume multiplier (`0.0` = muted, `1.0` = normal, higher = boosted).
+   */
   setOutputVolume(value: number): void;
+
+  /**
+   * Sets the recording gain applied to the local microphone before broadcasting.
+   * @param value - Volume multiplier (`0.0` to `1.0`).
+   */
   setInputVolume(value: number): void;
+
+  /**
+   * Sets the voice activity detection threshold.
+   * Audio below this level is silenced and not transmitted.
+   * @param value - Sensitivity cutoff value.
+   */
   setMicrophoneSensitivity(value: number): void;
 
+  /**
+   * Returns the names of all available audio output devices.
+   * @returns Array of device name strings.
+   */
   getOutputDevices(): string[];
+
+  /**
+   * Returns the names of all available audio input devices.
+   * @returns Array of device name strings.
+   */
   getInputDevices(): string[];
 
+  /**
+   * Selects the audio output device by its index in {@link getOutputDevices}.
+   * @param index - Device index.
+   */
   setOutputDevice(index: number): void;
+
+  /**
+   * Selects the microphone input device by its index in {@link getInputDevices}.
+   * @param index - Device index.
+   */
   setInputDevice(index: number): void;
 
+  /**
+   * Sets the maximum distance at which the local microphone transmits.
+   * @param distance - Transmission radius in world units.
+   */
   setInputDistance(distance: number): void;
+
+  /**
+   * Sets the maximum distance over which a remote player's voice attenuates to silence.
+   * @param distance - Audible radius in world units.
+   */
   setOutputDistance(distance: number): void;
 
+  /**
+   * Returns whether the voice chat system is initialized and connected.
+   * @returns `true` if active and ready, `false` otherwise.
+   */
   isActive(): boolean;
 
+  /**
+   * Returns whether the given player is currently transmitting voice audio.
+   * @param playerId - Target player's network ID.
+   * @returns `true` if the player is talking, `false` otherwise.
+   */
   isPlayerTalking(playerId: number): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cybermp-community/client-types",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "TypeScript type definitions for the CyberMP client-side environment.",
   "license": "CC BY-SA 4.0",
   "author": {
@@ -13,7 +13,7 @@
   ],
   "repository": {
     "type": "gitlab",
-    "url": "https://gitlab.com/cybermp/types/client"
+    "url": "git+https://gitlab.com/cybermp/types/client.git"
   },
   "publishConfig": {
     "access": "public"
@@ -42,6 +42,8 @@
     "types:apply-modified": "tsx ./scripts/apply-modified.ts",
     "types:generate": "tsx ./src",
     "generate": "bun run dumps:generate && bun run types:apply-modified && bun run types:generate",
+    "build": "bun run generate",
+    "prepublishOnly": "bun run generate",
     "bump": "npm version patch --no-git-tag-version",
     "pub": "npm publish --access public"
   },