@erlcjs/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1218 @@
+import { EventEmitter } from 'node:events';
+
+/**
+ * Configuration options for the ERLCApi Client.
+ * @public
+ */
+interface ClientOptions {
+    /**
+     * The ER:LC Server API Key.
+     */
+    serverKey: string;
+    /**
+     * Optional global key for wider API access.
+     */
+    globalKey?: string;
+    /**
+     * Webhook configuration details.
+     */
+    webhook?: {
+        /**
+         * Whether to enable the webhook server.
+         */
+        enabled: boolean;
+        /**
+         * The port to run the webhook server on.
+         */
+        port: number;
+        /**
+         * The URL path for incoming webhooks.
+         */
+        path?: string;
+        /**
+         * Secret key used for authenticating incoming webhooks.
+         */
+        secret?: string;
+    };
+    /**
+     * Whether to poll the ER:LC API endpoints periodically.
+     */
+    polling?: boolean;
+}
+/**
+ * Raw data structure representing a player from the ERLC API.
+ * @public
+ */
+interface RawPlayerData {
+    /**
+     * The player identifier, in the format `Username:UserId`.
+     */
+    Player: string;
+    /**
+     * The permission level of the player in the server.
+     */
+    Permission: 'Normal' | 'Server Administrator' | 'Server Owner' | 'Server Moderator';
+    /**
+     * The team the player is currently on.
+     */
+    Team: string;
+    /**
+     * The player's optional callsign.
+     */
+    Callsign: string;
+    /**
+     * The player's location coordinates and address details.
+     */
+    Location: {
+        /**
+         * The X coordinate of the player in the game.
+         */
+        LocationX: number;
+        /**
+         * The Y coordinate of the player in the game.
+         */
+        LocationY: number;
+        /**
+         * The postal code of the player's location.
+         */
+        PostalCode: string;
+        /**
+         * The street name of the player's location.
+         */
+        StreetName: string;
+        /**
+         * The building number of the player's location.
+         */
+        BuildingNumber: string;
+    };
+    /**
+     * The number of wanted stars the player currently has.
+     */
+    WantedStars: number;
+}
+/**
+ * Raw data structure representing server staff records.
+ * @public
+ */
+interface RawStaffData {
+    /**
+     * Record of server administrators (UserId to Username).
+     */
+    Admins: Record<string, string>;
+    /**
+     * Record of server moderators (UserId to Username).
+     */
+    Mods: Record<string, string>;
+    /**
+     * Record of server helpers (UserId to Username).
+     */
+    Helpers: Record<string, string>;
+}
+/**
+ * Raw data structure representing a server join/leave log entry.
+ * @public
+ */
+interface RawJoinLog {
+    /**
+     * True if the player joined, false if they left.
+     */
+    Join: boolean;
+    /**
+     * Unix timestamp of when the event occurred.
+     */
+    Timestamp: number;
+    /**
+     * The player identifier, in the format `Username:UserId`.
+     */
+    Player: string;
+}
+/**
+ * Raw data structure representing a kill log entry.
+ * @public
+ */
+interface RawKillLog {
+    /**
+     * The identifier of the player who was killed (`Username:UserId`).
+     */
+    Killed: string;
+    /**
+     * Unix timestamp of when the kill occurred.
+     */
+    Timestamp: number;
+    /**
+     * The identifier of the player who did the killing (`Username:UserId`).
+     */
+    Killer: string;
+}
+/**
+ * Raw data structure representing a executed command log entry.
+ * @public
+ */
+interface RawCommandLog {
+    /**
+     * The identifier of the player who ran the command (`Username:UserId`).
+     */
+    Player: string;
+    /**
+     * Unix timestamp of when the command was run.
+     */
+    Timestamp: number;
+    /**
+     * The command string that was executed.
+     */
+    Command: string;
+}
+/**
+ * Raw data structure representing a moderator call log.
+ * @public
+ */
+interface RawModCall {
+    /**
+     * The identifier of the caller (`Username:UserId`).
+     */
+    Caller: string;
+    /**
+     * The identifier of the moderator who responded, if any (`Username:UserId`).
+     */
+    Moderator?: string;
+    /**
+     * Unix timestamp of the moderator call.
+     */
+    Timestamp: number;
+}
+/**
+ * Raw data structure representing an emergency call.
+ * @public
+ */
+interface RawEmergencyCall {
+    /**
+     * The team name associated with the emergency call.
+     */
+    Team: string;
+    /**
+     * The UserId of the player who made the call.
+     */
+    Caller: number;
+    /**
+     * List of UserIds of responders currently assigned to this call.
+     */
+    Players: number[];
+    /**
+     * Position coordinates [x, y] of the emergency call.
+     */
+    Position: number[];
+    /**
+     * Unix timestamp of when the call was created.
+     */
+    StartedAt: number;
+    /**
+     * The unique call number.
+     */
+    CallNumber: number;
+    /**
+     * The description text of the call.
+     */
+    Description: string;
+    /**
+     * Descriptors of the position where the call was made.
+     */
+    PositionDescriptor: string;
+}
+/**
+ * Raw data structure representing a vehicle.
+ * @public
+ */
+interface RawVehicle {
+    /**
+     * The name/model of the vehicle.
+     */
+    Name: string;
+    /**
+     * The username of the vehicle owner.
+     */
+    Owner: string;
+    /**
+     * The license plate of the vehicle.
+     */
+    Plate: string;
+    /**
+     * The custom texture path or name of the vehicle.
+     */
+    Texture?: string;
+    /**
+     * Hexadecimal color code of the vehicle.
+     */
+    ColorHex: string;
+    /**
+     * The color name of the vehicle.
+     */
+    ColorName: string;
+}
+/**
+ * Raw data structure representing the full server information payload from ER:LC.
+ * @public
+ */
+interface RawServerData {
+    /**
+     * The server name.
+     */
+    Name: string;
+    /**
+     * The UserId of the server owner.
+     */
+    OwnerId: number;
+    /**
+     * List of UserIds of server co-owners.
+     */
+    CoOwnerIds: number[];
+    /**
+     * Number of players currently in the server.
+     */
+    CurrentPlayers: number;
+    /**
+     * Maximum allowed players in the server.
+     */
+    MaxPlayers: number;
+    /**
+     * The join key of the server.
+     */
+    JoinKey: string;
+    /**
+     * Verification level requirement for joining.
+     */
+    AccVerifiedReq: 'Disabled' | 'Email' | 'Phone/ID';
+    /**
+     * Whether team balance is enabled.
+     */
+    TeamBalance: boolean;
+    /**
+     * List of active players.
+     */
+    Players?: RawPlayerData[];
+    /**
+     * Server staff lists.
+     */
+    Staff?: RawStaffData[];
+    /**
+     * Server join/leave logs.
+     */
+    JoinLogs?: RawJoinLog[];
+    /**
+     * UserIds currently in the join queue.
+     */
+    Queue?: number[];
+    /**
+     * Server kill logs.
+     */
+    KillLogs?: RawKillLog[];
+    /**
+     * Server command logs.
+     */
+    CommandLogs?: RawCommandLog[];
+    /**
+     * Active moderator calls.
+     */
+    ModCalls?: RawModCall[];
+    /**
+     * Active emergency calls.
+     */
+    EmergencyCalls?: RawEmergencyCall[];
+    /**
+     * Active vehicles spawned.
+     */
+    Vehicles?: RawVehicle[];
+}
+
+/**
+ * Handles communication with the ER:LC HTTP API, managing rate limits and request queuing.
+ * @public
+ */
+declare class RestManager {
+    private options;
+    private queue;
+    private processing;
+    private rateLimitReset;
+    private baseUrl;
+    /**
+     * Creates an instance of RestManager.
+     * @param options - The ClientOptions configuration.
+     */
+    constructor(options: ClientOptions);
+    /**
+     * Enqueues and sends an HTTP request to the ER:LC API.
+     * @param method - The HTTP method to use ('GET' or 'POST').
+     * @param endpoint - The API endpoint path.
+     * @param body - The optional request body payload.
+     * @returns A promise resolving to the API response data.
+     * @throws {@link InvalidServerKeyError} if the server API key is invalid (403).
+     * @throws Error - for other HTTP error codes.
+     */
+    request(method: 'GET' | 'POST', endpoint: string, body?: any): Promise<any>;
+    /**
+     * Processes the request queue sequentially.
+     */
+    private processQueue;
+}
+
+/**
+ * Represents the base class for all ER:LC structures.
+ * @public
+ */
+declare class Base {
+    readonly client: Client;
+    /**
+     * Creates an instance of the Base class.
+     * @param client - The ERLCApi client instance.
+     */
+    constructor(client: Client);
+}
+
+/**
+ * Represents the ER:LC game server and its current configuration/state.
+ * @public
+ */
+declare class Server extends Base {
+    /**
+     * The name of the server.
+     */
+    name: string;
+    /**
+     * The UserId of the server owner.
+     */
+    ownerId: number;
+    /**
+     * Array of UserIds of server co-owners.
+     */
+    coOwnerIds: number[];
+    /**
+     * The current number of players connected to the server.
+     */
+    currentPlayers: number;
+    /**
+     * The maximum number of players allowed in the server.
+     */
+    maxPlayers: number;
+    /**
+     * The join key of the server.
+     */
+    joinKey: string;
+    /**
+     * Account verification requirements for joining.
+     */
+    accVerifiedReq: 'Disabled' | 'Email' | 'Phone/ID';
+    /**
+     * Whether team balance enforcement is enabled.
+     */
+    teamBalance: boolean;
+    /**
+     * The queue of players waiting to join the server.
+     */
+    queue: number[];
+    /**
+     * Creates an instance of Server.
+     * @param client - The ERLCApi client.
+     * @param data - The raw server data to initialize.
+     */
+    constructor(client: Client, data: RawServerData);
+    /**
+     * Patches the Server instance with new raw data.
+     * @param data - The new raw server data.
+     * @returns This server instance.
+     */
+    _patch(data: RawServerData): this;
+    /**
+     * Compares the current server data with another raw data payload to check if it's identical.
+     * @param data - The raw server data to compare against.
+     * @returns True if the properties are identical, false otherwise.
+     */
+    compare(data: RawServerData): boolean;
+    /**
+     * Converts this Server instance back to its raw JSON structure.
+     * @returns The raw server data.
+     */
+    toJSON(): RawServerData;
+}
+
+/**
+ * Manager responsible for fetching and caching the ER:LC Server details.
+ * @public
+ */
+declare class ServerManager {
+    private readonly client;
+    /**
+     * Cached Server structure instance, if fetched.
+     */
+    cache?: Server;
+    /**
+     * Creates an instance of ServerManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches current server information from the API.
+     * Patches the cache and emits event updates if there are changes.
+     * @returns A promise resolving to the raw server data from the API.
+     */
+    fetch(): Promise<RawServerData>;
+}
+
+/**
+ * Represents a player in the ER:LC server.
+ * @public
+ */
+declare class Player extends Base {
+    /**
+     * The unique UserId of the player.
+     */
+    id: number;
+    /**
+     * The Roblox username of the player.
+     */
+    username: string;
+    /**
+     * The in-game team name the player is currently on.
+     */
+    team: string;
+    /**
+     * The player's callsign, if assigned.
+     */
+    callsign?: string;
+    /**
+     * The current location coordinates and address of the player.
+     */
+    location: {
+        /** The X coordinate in-game. */
+        x: number;
+        /** The Y coordinate in-game. */
+        y: number;
+        /** The postal code of the street. */
+        postalCode: string;
+        /** The name of the street. */
+        streetName: string;
+        /** The building number. */
+        buildingNumber: string;
+    };
+    /**
+     * The player's server permission role.
+     */
+    permission: 'Normal' | 'Server Administrator' | 'Server Owner' | 'Server Moderator';
+    /**
+     * The player's current wanted star level.
+     */
+    wantedLevel: number;
+    /**
+     * Creates an instance of Player.
+     * @param client - The ERLCApi client.
+     * @param data - The raw player data to initialize.
+     */
+    constructor(client: Client, data: RawPlayerData);
+    /**
+     * Patches/updates the player structure with new raw data.
+     * @param data - The new raw player data.
+     * @returns This player instance.
+     */
+    _patch(data: RawPlayerData): this;
+    /**
+     * Kicks the player from the game server.
+     * @param reason - The reason for kicking the player. Defaults to "Kicked by API".
+     * @returns A promise that resolves when the kick command is sent.
+     */
+    kick(reason?: string): Promise<void>;
+    /**
+     * Bans the player from the game server.
+     * @param reason - The reason for banning the player. Defaults to "Banned by API".
+     * @returns A promise that resolves when the ban command is sent.
+     */
+    ban(reason?: string): Promise<void>;
+    /**
+     * Jails the player in the game server.
+     * @returns A promise that resolves when the jail command is sent.
+     */
+    jail(): Promise<void>;
+    /**
+     * Heals the player in the game server.
+     * @returns A promise that resolves when the heal command is sent.
+     */
+    heal(): Promise<void>;
+    /**
+     * Kills the player in-game.
+     * @returns A promise that resolves when the kill command is sent.
+     */
+    kill(): Promise<void>;
+    /**
+     * Helpers the player in-game.
+     * @returns A promise that resolves when the helper command is sent.
+     */
+    helper(): Promise<void>;
+    /**
+     * Unhelpers the player in-game.
+     * @returns A promise that resolves when the unhelper command is sent.
+     */
+    unhelper(): Promise<void>;
+    /**
+     * Mods the player in-game.
+     * @returns A promise that resolves when the mod command is sent.
+     */
+    mod(): Promise<void>;
+    /**
+     * Unmods the player in-game.
+     * @returns A promise that resolves when the unmod command is sent.
+     */
+    unmod(): Promise<void>;
+    /**
+     * Admins the player in-game.
+     * @returns A promise that resolves when the admin command is sent.
+     */
+    admin(): Promise<void>;
+    /**
+     * Unadmins the player in-game.
+     * @returns A promise that resolves when the unadmin command is sent.
+     */
+    unadmin(): Promise<void>;
+    /**
+     * Teleports the player to another player.
+     * @param player - The player to teleport the player to.
+     * @returns A promise that resolves when the teleport command is sent.
+     */
+    tp(player: Player | number): Promise<void>;
+    /**
+     * Sends a private message to the player.
+     * @param text - The message body.
+     * @returns A promise that resolves when the message command is sent.
+     */
+    message(text: string): Promise<void>;
+    /**
+     * Sends a private message to the player.
+     * @param text - The message body.
+     * @returns A promise that resolves when the message command is sent.
+     */
+    pm(text: string): Promise<void>;
+    /**
+     * Converts this Player instance back into raw data structure.
+     * @returns The raw player data.
+     */
+    toJSON(): RawPlayerData;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating Player structures.
+ * @public
+ */
+declare class PlayerManager {
+    private readonly client;
+    /**
+     * Map cache of online Players, keyed by their UserId.
+     */
+    cache: Map<number, Player>;
+    private nameToId;
+    /**
+     * Creates an instance of PlayerManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all active players currently in the game server.
+     * Updates the player cache.
+     * @returns A promise resolving to a Map of active Players.
+     */
+    fetchAll(): Promise<Map<number, Player>>;
+    /**
+     * Re-synchronizes the cache with the raw player list from the API.
+     * Emits playerJoin, playerLeave, and playerUpdate events.
+     * @param rawPlayers - Raw player list payload.
+     * @returns The updated Player cache Map.
+     */
+    updateCache(rawPlayers: RawPlayerData[]): Map<number, Player>;
+    /**
+     * Retrieves a player's UserId from their Roblox username.
+     * Attempts to resolve from cache first, otherwise triggers a fresh fetch.
+     * @param name - The Roblox username.
+     * @returns The UserId if resolved, otherwise undefined.
+     */
+    getIdFromName(name: string): number | undefined;
+}
+
+/**
+ * Manager responsible for executing custom console commands in the ER:LC server.
+ * @public
+ */
+declare class CommandManager {
+    private readonly client;
+    /**
+     * Creates an instance of CommandManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Executes a server command via the ER:LC API.
+     * @param command - The full command string to execute (e.g. `:pm jamie hello`).
+     * @returns A promise resolving to the API response string status.
+     */
+    execute(command: string): Promise<string>;
+}
+
+/**
+ * Represents a spawned vehicle in the ER:LC server.
+ * @public
+ */
+declare class Vehicle extends Base {
+    /**
+     * The name/model of the vehicle.
+     */
+    name: string;
+    /**
+     * The UserId of the vehicle owner.
+     */
+    ownerId: number;
+    /**
+     * The username of the vehicle owner.
+     */
+    ownerUsername: string;
+    /**
+     * The Player instance representing the owner, if they are currently online.
+     */
+    owner: Player;
+    /**
+     * The license plate text of the vehicle.
+     */
+    plate: string;
+    /**
+     * The custom texture identifier, if any.
+     */
+    texture?: string;
+    /**
+     * The hexadecimal color code of the vehicle.
+     */
+    colorHex: string;
+    /**
+     * The user-friendly color name of the vehicle.
+     */
+    colorName: string;
+    /**
+     * Creates an instance of Vehicle.
+     * @param client - The ERLCApi client.
+     * @param data - The raw vehicle data to initialize.
+     */
+    constructor(client: Client, data: RawVehicle);
+    /**
+     * Patches the Vehicle structure with new raw data.
+     * @param data - The new raw vehicle data.
+     * @returns This vehicle instance.
+     */
+    _patch(data: RawVehicle): this;
+    /**
+     * Converts this Vehicle instance to raw JSON representation.
+     * @returns The raw vehicle data.
+     */
+    toJSON(): RawVehicle;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating Vehicle structures.
+ * @public
+ */
+declare class VehicleManager {
+    private readonly client;
+    /**
+     * Map cache of spawned vehicles in the server, keyed by their license plate.
+     */
+    cache: Map<string, Vehicle>;
+    /**
+     * Creates an instance of VehicleManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all active vehicles currently spawned in the game server.
+     * Updates the vehicle cache.
+     * @returns A promise resolving to a Map of active Vehicles.
+     */
+    fetchAll(): Promise<Map<string, Vehicle>>;
+    /**
+     * Re-synchronizes the cache with the raw vehicle list from the API.
+     * Emits vehicleAdd, vehicleRemove, and vehicleUpdate events.
+     * @param rawVehicles - Raw vehicle list payload.
+     * @returns The updated Vehicle cache Map.
+     */
+    updateCache(rawVehicles: RawVehicle[]): Map<string, Vehicle>;
+}
+
+/**
+ * Represents a logged command execution event.
+ * @public
+ */
+declare class CommandLog extends Base {
+    /**
+     * The player instance representing who ran the command.
+     */
+    player: Player;
+    /**
+     * The UserId of the player who ran the command.
+     */
+    playerId: number;
+    /**
+     * The username of the player who ran the command.
+     */
+    playerUsername: string;
+    /**
+     * Unix timestamp of when the command was run.
+     */
+    timestamp: number;
+    /**
+     * The full command string executed.
+     */
+    command: string;
+    /**
+     * Creates an instance of CommandLog.
+     * @param client - The ERLCApi client.
+     * @param data - The raw command log data to initialize.
+     */
+    constructor(client: Client, data: RawCommandLog);
+    /**
+     * Patches the CommandLog structure with new raw data.
+     * @param data - The new raw command log data.
+     * @returns This command log instance.
+     */
+    _patch(data: RawCommandLog): this;
+    /**
+     * Converts this CommandLog instance to raw JSON representation.
+     * @returns The raw command log data.
+     */
+    toJSON(): RawCommandLog;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating CommandLog structures.
+ * @public
+ */
+declare class CommandLogManager {
+    private readonly client;
+    /**
+     * Map cache of logged commands, keyed by a composite `Player:Timestamp` key.
+     */
+    cache: Map<string, CommandLog>;
+    /**
+     * Creates an instance of CommandLogManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all command logs from the game server.
+     * Updates the command log cache.
+     * @returns A promise resolving to a Map of CommandLogs.
+     */
+    fetchAll(): Promise<Map<string, CommandLog>>;
+    /**
+     * Re-synchronizes the cache with the raw command logs.
+     * Emits command event for new logs.
+     * @param rawCommands - Raw command logs payload.
+     * @returns The updated CommandLog cache Map.
+     */
+    updateCache(rawCommands: RawCommandLog[]): Map<string, CommandLog>;
+}
+
+/**
+ * Represents an active emergency call in the ER:LC server.
+ * @public
+ */
+declare class EmergencyCall extends Base {
+    /**
+     * The Player instance representing the caller.
+     */
+    caller: Player;
+    /**
+     * The UserId of the player who made the emergency call.
+     */
+    callerId: number;
+    /**
+     * The team associated with the emergency call (e.g., "Police", "Fire").
+     */
+    team: string;
+    /**
+     * Array of UserIds of responders assigned to this call.
+     */
+    playerIds: number[];
+    /**
+     * Array of Player instances of active responders assigned to this call.
+     */
+    players: Player[];
+    /**
+     * The game position coordinates [x, y] of the call.
+     */
+    position: number[];
+    /**
+     * Unix timestamp of when the call was started.
+     */
+    startedAt: number;
+    /**
+     * The unique call number.
+     */
+    callNumber: number;
+    /**
+     * The description text of the emergency call.
+     */
+    description: string;
+    /**
+     * Positional description of where the call was made.
+     */
+    positionDescriptor: string;
+    /**
+     * Creates an instance of EmergencyCall.
+     * @param client - The ERLCApi client.
+     * @param data - The raw emergency call data to initialize.
+     */
+    constructor(client: Client, data: RawEmergencyCall);
+    /**
+     * Patches the EmergencyCall structure with new raw data.
+     * @param data - The new raw emergency call data.
+     * @returns This emergency call instance.
+     */
+    _patch(data: RawEmergencyCall): this;
+    /**
+     * Converts this EmergencyCall instance to raw JSON representation.
+     * @returns The raw emergency call data.
+     */
+    toJSON(): RawEmergencyCall;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating active EmergencyCall structures.
+ * @public
+ */
+declare class EmergencyCallManager {
+    private readonly client;
+    /**
+     * Map cache of active emergency calls, keyed by call number.
+     */
+    cache: Map<number, EmergencyCall>;
+    /**
+     * Creates an instance of EmergencyCallManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all active emergency calls from the game server.
+     * Updates the emergency call cache.
+     * @returns A promise resolving to a Map of active EmergencyCalls.
+     */
+    fetchAll(): Promise<Map<number, EmergencyCall>>;
+    /**
+     * Re-synchronizes the cache with the raw emergency calls payload.
+     * Emits emergencyCallAdd, emergencyCallRemove, and emergencyCallUpdate events.
+     * @param rawCalls - Raw active emergency calls payload.
+     * @returns The updated EmergencyCall cache Map.
+     */
+    updateCache(rawCalls: RawEmergencyCall[]): Map<number, EmergencyCall>;
+}
+
+/**
+ * Represents a log of a player death event (kill).
+ * @public
+ */
+declare class KillLog extends Base {
+    /**
+     * The Player instance representing the player who was killed.
+     */
+    killed: Player;
+    /**
+     * The UserId of the player who was killed.
+     */
+    killedId: number;
+    /**
+     * The Roblox username of the player who was killed.
+     */
+    killedUsername: string;
+    /**
+     * The Player instance representing the player who did the killing.
+     */
+    killer: Player;
+    /**
+     * The UserId of the player who did the killing.
+     */
+    killerId: number;
+    /**
+     * The Roblox username of the player who did the killing.
+     */
+    killerUsername: string;
+    /**
+     * Unix timestamp of when the kill occurred.
+     */
+    timestamp: number;
+    /**
+     * Creates an instance of KillLog.
+     * @param client - The ERLCApi client.
+     * @param data - The raw kill log data.
+     */
+    constructor(client: Client, data: RawKillLog);
+    /**
+     * Patches the KillLog structure with new raw data.
+     * @param data - The new raw kill log data.
+     * @returns This kill log instance.
+     */
+    _patch(data: RawKillLog): this;
+    /**
+     * Converts this KillLog instance to raw JSON representation.
+     * @returns The raw kill log data.
+     */
+    toJSON(): RawKillLog;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating KillLog structures.
+ * @public
+ */
+declare class KillLogManager {
+    private readonly client;
+    /**
+     * Map cache of logged kills, keyed by a composite `Killer:Killed:Timestamp` key.
+     */
+    cache: Map<string, KillLog>;
+    /**
+     * Creates an instance of KillLogManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all kill logs from the game server.
+     * Updates the kill log cache.
+     * @returns A promise resolving to a Map of KillLogs.
+     */
+    fetchAll(): Promise<Map<string, KillLog>>;
+    /**
+     * Re-synchronizes the cache with the raw kill logs.
+     * Emits a kill event for new logs.
+     * @param rawCommands - Raw kill logs payload.
+     * @returns The updated KillLog cache Map.
+     */
+    updateCache(rawCommands: RawKillLog[]): Map<string, KillLog>;
+}
+
+/**
+ * Represents a request for moderation help (moderator call) in the ER:LC server.
+ * @public
+ */
+declare class ModCall extends Base {
+    /**
+     * The Player instance representing the caller.
+     */
+    caller: Player;
+    /**
+     * The UserId of the player who made the moderator call.
+     */
+    callerId: number;
+    /**
+     * The Roblox username of the caller.
+     */
+    callerUsername: string;
+    /**
+     * Unix timestamp of the moderator call.
+     */
+    timestamp: number;
+    /**
+     * The Player instance representing the moderator who responded, if any.
+     */
+    moderator?: Player;
+    /**
+     * The UserId of the moderator who responded, if any.
+     */
+    moderatorId?: number;
+    /**
+     * The Roblox username of the moderator who responded, if any.
+     */
+    moderatorUsername?: string;
+    /**
+     * Creates an instance of ModCall.
+     * @param client - The ERLCApi client.
+     * @param data - The raw moderator call data.
+     */
+    constructor(client: Client, data: RawModCall);
+    /**
+     * Patches the ModCall structure with new raw data.
+     * @param data - The new raw moderator call data.
+     * @returns This moderator call instance.
+     */
+    _patch(data: RawModCall): this;
+    /**
+     * Converts this ModCall instance to raw JSON representation.
+     * @returns The raw moderator call data.
+     */
+    toJSON(): RawModCall;
+}
+
+/**
+ * Manager responsible for fetching, caching, and updating ModCall structures.
+ * @public
+ */
+declare class ModCallManager {
+    private readonly client;
+    /**
+     * Map cache of logged moderator calls, keyed by a composite `Caller:Timestamp` key.
+     */
+    cache: Map<string, ModCall>;
+    /**
+     * Creates an instance of ModCallManager.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Fetches all moderator calls from the game server.
+     * Updates the moderator call cache.
+     * @returns A promise resolving to a Map of ModCalls.
+     */
+    fetchAll(): Promise<Map<string, ModCall>>;
+    /**
+     * Re-synchronizes the cache with the raw moderator calls.
+     * Emits a modCall event for new calls.
+     * @param rawCommands - Raw moderator calls payload.
+     * @returns The updated ModCall cache Map.
+     */
+    updateCache(rawCommands: RawModCall[]): Map<string, ModCall>;
+}
+
+/**
+ * Event names emitted by the ERLCApi Client.
+ * @public
+ */
+declare enum ERLCEvents {
+    /** Emitted when a periodic server poll finishes. */
+    poll = "POLL",
+    /** Emitted when server details are updated. */
+    serverUpdate = "SERVER_UPDATE",
+    /** Emitted when server details are first loaded. */
+    serverCreate = "SERVER_CREATE",
+    /** Emitted when a player joins the server. */
+    playerJoin = "PLAYER_JOIN",
+    /** Emitted when a player's data (e.g. location, team) updates. */
+    playerUpdate = "PLAYER_UPDATE",
+    /** Emitted when a player leaves the server. */
+    playerLeave = "PLAYER_LEAVE",
+    /** Emitted when a vehicle is spawned. */
+    vehicleAdd = "VEHICLE_ADD",
+    /** Emitted when a vehicle is despawned. */
+    vehicleRemove = "VEHICLE_REMOVE",
+    /** Emitted when a vehicle's data updates. */
+    vehicleUpdate = "VEHICLE_UPDATE",
+    /** Emitted when a server command is run. */
+    command = "COMMAND",
+    /** Emitted when a player requests moderator assistance. */
+    modCall = "MOD_CALL",
+    /** Emitted when a player is killed. */
+    kill = "KILL",
+    /** Emitted when an emergency call is created. */
+    emergencyCallAdd = "EMERGENCY_CALL_ADD",
+    /** Emitted when an emergency call is cleared. */
+    emergencyCallRemove = "EMERGENCY_CALL_REMOVE",
+    /** Emitted when an emergency call is updated. */
+    emergencyCallUpdate = "EMERGENCY_CALL_UPDATE"
+}
+/**
+ * Interface mapping client event names to their callback parameters.
+ * @public
+ */
+interface ClientEvents {
+    /** Emitted when a periodic server poll finishes. */
+    [ERLCEvents.poll]: [server: RawServerData];
+    /** Emitted when server details are updated. */
+    [ERLCEvents.serverUpdate]: [oldServer: Server | null, newServer: Server];
+    /** Emitted when server details are first loaded. */
+    [ERLCEvents.serverCreate]: [server: Server];
+    /** Emitted when a player joins the server. */
+    [ERLCEvents.playerJoin]: [player: Player];
+    /** Emitted when a player's data updates. */
+    [ERLCEvents.playerUpdate]: [oldPlayer: Player | null, newPlayer: Player];
+    /** Emitted when a player leaves the server. */
+    [ERLCEvents.playerLeave]: [player: Player];
+    /** Emitted when a vehicle is spawned. */
+    [ERLCEvents.vehicleAdd]: [vehicle: Vehicle];
+    /** Emitted when a vehicle is despawned. */
+    [ERLCEvents.vehicleRemove]: [vehicle: Vehicle];
+    /** Emitted when a vehicle's data updates. */
+    [ERLCEvents.vehicleUpdate]: [oldVehicle: Vehicle | null, newVehicle: Vehicle];
+    /** Emitted when a server command is run. */
+    [ERLCEvents.command]: [log: CommandLog];
+    /** Emitted when a player requests moderator assistance. */
+    [ERLCEvents.modCall]: [call: ModCall];
+    /** Emitted when a player is killed. */
+    [ERLCEvents.kill]: [kill: KillLog];
+    /** Emitted when an emergency call is created. */
+    [ERLCEvents.emergencyCallAdd]: [call: EmergencyCall];
+    /** Emitted when an emergency call is cleared. */
+    [ERLCEvents.emergencyCallRemove]: [call: EmergencyCall];
+    /** Emitted when an emergency call is updated. */
+    [ERLCEvents.emergencyCallUpdate]: [oldCall: EmergencyCall | null, newCall: EmergencyCall];
+    /** Emitted when an error is caught during polling or gateway operations. */
+    error: [error: unknown];
+}
+/**
+ * The main client for interacting with the ER:LC API and gateway.
+ * @public
+ */
+declare class Client extends EventEmitter<ClientEvents> {
+    options: ClientOptions;
+    /** REST Manager for sending manual requests to the ER:LC API. */
+    rest: RestManager;
+    /** Manager for fetching and caching general server configuration. */
+    server: ServerManager;
+    /** Manager for player caching, joining, and management actions. */
+    players: PlayerManager;
+    /** Manager for executing server-side console commands. */
+    commands: CommandManager;
+    /** Manager for spawned vehicles cache and events. */
+    vehicles: VehicleManager;
+    /** Manager for command execution log events. */
+    commandLogs: CommandLogManager;
+    /** Manager for active emergency calls. */
+    emergencyCalls: EmergencyCallManager;
+    /** Manager for kill logs. */
+    killLogs: KillLogManager;
+    /** Manager for moderator call logs. */
+    modCalls: ModCallManager;
+    /** Webhook Gateway server instance, if enabled. */
+    private readonly gateway?;
+    /**
+     * Creates an instance of Client.
+     * @param options - The ClientOptions configuration.
+     */
+    constructor(options: ClientOptions);
+    /**
+     * Starts the periodic api-polling loop if enabled.
+     */
+    private startPolling;
+}
+
+/**
+ * Webhook Server for handling real-time gateway events pushed by ER:LC.
+ * @alpha
+ */
+declare class WebhookServer {
+    private client;
+    private server;
+    /**
+     * Creates an instance of WebhookServer.
+     * @param client - The ERLCApi client.
+     */
+    constructor(client: Client);
+    /**
+     * Starts listening for incoming webhook events.
+     */
+    listen(): void;
+    /**
+     * Internally processes gateway event payload.
+     * @param payload - Raw JSON payload received.
+     */
+    private handleGatewayEvent;
+}
+
+/**
+ * Error thrown when an invalid ER:LC Server API Key is provided.
+ * @public
+ */
+declare class InvalidServerKeyError extends Error {
+    /**
+     * Creates an instance of InvalidServerKeyError.
+     * @param message - The error message. Defaults to 'Invalid Server API Key.'.
+     */
+    constructor(message?: string);
+}
+
+export { Base, Client, type ClientEvents, type ClientOptions, CommandLog, CommandLogManager, CommandManager, ERLCEvents, EmergencyCall, EmergencyCallManager, InvalidServerKeyError, KillLog, KillLogManager, ModCall, ModCallManager, Player, PlayerManager, type RawCommandLog, type RawEmergencyCall, type RawJoinLog, type RawKillLog, type RawModCall, type RawPlayerData, type RawServerData, type RawStaffData, type RawVehicle, RestManager, Server, ServerManager, Vehicle, VehicleManager, WebhookServer };