rustcon-js/dist/index.d.mts

RustCON JS is a JavaScript library for interacting with Rust servers via WebSockets (Web RCON)

import { WebSocket } from 'unws';
import { EventEmitter } from 'events';

interface GenericMessage {
    Message: string;
    Identifier: number;
    Type: string;
    Stacktrace: string;
}
interface ServerInfo$1 {
    Hostname: string;
    MaxPlayers: number;
    Players: number;
    Queued: number;
    Joining: number;
    EntityCount: number;
    GameTime: string;
    Uptime: number;
    Map: string;
    Framerate: number;
    Memory: number;
    MemoryUsageSystem: number;
    Collections: number;
    NetworkIn: number;
    NetworkOut: number;
    Restarting: boolean;
    SaveCreatedTime: string;
    Version: number;
    Protocol: string;
}
interface PlayerInfo {
    SteamID: string;
    OwnerSteamID: string;
    DisplayName: string;
    Ping: number;
    Address: string;
    ConnectedSeconds: number;
    VoiationLevel: number;
    CurrentLevel: number;
    UnspentXp: number;
    Health: number;
}

declare class ServerInfo {
    /**
     * Server hostname
     * @type {string}
     */
    hostname: string;
    /**
     *
     * @type {number}
     */
    players: number;
    /**
     *
     * @type {number}
     */
    maxPlayers: number;
    /**
     *
     * @type {number}
     */
    queuedPlayers: number;
    /**
     *
     * @type {number}
     */
    joiningPlayers: number;
    /**
     * Server entity count
     * @type {number}
     */
    entityCount: number;
    /**
     * Server game time
     * @type {string}
     */
    gameTime: string;
    /**
     * Server uptime (seconds)
     * @type {number}
     */
    uptime: number;
    /**
     * Server map type
     * @type {string}
     */
    map: string;
    /**
     * Server framerate
     * @type {number}
     */
    framerate: number;
    /**
     * Server memory usage
     * @type {number}
     */
    memory: number;
    /**
     * System memory usage
     * @type {number}
     */
    memoryUsageSystem: number;
    /**
     *
     * @type {number}
     */
    collections: number;
    /**
     * Server network in (bytes)
     * @type {number}
     */
    networkIn: number;
    /**
     * Server network out (bytes)
     * @type {number}
     */
    networkOut: number;
    /**
     * Is the server restarting
     * @type {boolean}
     */
    restarting: boolean;
    /**
     * Server save created time
     * @type {string}
     */
    saveCreatedTime: string;
    /**
     * Server version
     * @type {number}
     */
    version: number;
    /**
     * Server protocol
     * @type {string}
     */
    protocol: string;
    constructor(serverInfo: ServerInfo$1);
    /**
     * Check if the server is full
     * @returns {boolean}
     */
    isFull(): boolean;
    /**
     * Check if the server has a queue
     * @returns {boolean}
     */
    hasQueue(): boolean;
    /**
     * Check if the server has players joining
     * @returns {boolean}
     */
    hasPlayersJoining(): boolean;
}

declare class ServerManager {
    private client;
    constructor(client: Client);
    /**
     * Get the server info
     * @returns {Promise<ServerInfo>}
     */
    getInfo(): Promise<ServerInfo>;
    /**
     * Save the server
     * @returns {Promise<void>}
     */
    save(): Promise<void>;
    /**
     * Save the server configuration
     * @returns {Promise<void>}
     */
    writeCFG(): Promise<void>;
    /**
     * Restart the server
     * @param {string} reason
     * @param {number} duration
     * @returns {Promise<void>}
     */
    restart(reason: string, duration: number): Promise<void>;
    /**
     * Shutdown the server
     * @param {string} reason
     * @param {number} duration
     * @returns {Promise<void>}
     */
    shutdown(reason: string, duration: number): Promise<void>;
    /**
     * Add a moderator to the server
     * @param {(number|string)} steamId
     * @param {string} name
     * @param {string} reason
     * @param {boolean} save
     * @returns {Promise<void>}
     */
    addModerator(steamId: string, name?: string, reason?: string, save?: boolean): Promise<void>;
    /**
     * Add an owner to the server
     * @param {(number|string)} steamId
     * @param {string} name
     * @param {string} reason
     * @param {boolean} save
     * @returns {Promise<void>}
     */
    addOwner(steamId: string, name?: string, reason?: string, save?: boolean): Promise<void>;
}

declare class Player {
    /**
     * Player name
     * @type {string}
     */
    name: string;
    /**
     * Player Steam ID
     * @type {string}
     */
    steamId: string;
    /**
     * Player IP address
     * @type {string}
     */
    ipAddress: string;
    /**
     * Player ping
     * @type {number}
     */
    ping: number;
    /**
     * Player health
     * @type {number}
     */
    health: number;
    /**
     * Player connected time (seconds)
     * @type {number}
     */
    connectedTime: number;
    private playersManager;
    constructor(player: PlayerInfo, playersManager: PlayersManager);
    /**
     * Kick player
     * @param {string} reason
     * @example
     * player.kick();
     * player.kick("You're a bad player!");
     */
    kick(reason?: string): Promise<void>;
    /**
     * Ban player
     * @param {string} reason
     * @example
     * player.ban();
     * player.ban("You're a bad player!");
     */
    ban(reason?: string): Promise<void>;
}

declare class PlayersManager {
    private client;
    constructor(client: Client);
    /**
     * Get all connected players
     * @returns {Promise<Player[]>}
     */
    getAll(): Promise<Player[]>;
    /**
     * Get a player by their Steam ID
     * @param {(number|string)} steamId
     * @returns {Promise<(Player|null)>}
     */
    get(steamId: number | string): Promise<Player | null>;
    /**
     * Kick a player
     * @param {(number|string)} steamId
     * @param {string} reason
     * @returns {Promise<void>}
     */
    kickPlayer(steamId: number | string, reason?: string): Promise<void>;
    /**
     * Ban a player
     * @param {(number|string)} steamId
     * @param {string} reason
     * @returns {Promise<void>}
     */
    banPlayer(steamId: number | string, reason?: string): Promise<void>;
    /**
     * Unban a player
     * @param {(number|string)} steamId
     * @returns {Promise<void>}
     */
    unbanPlayer(steamId: number | string): Promise<void>;
}

declare class Message {
    content: string;
    identifier: number;
    type: string;
    stacktrace: string;
    constructor(messageData: GenericMessage);
}

interface ConnectionOptions {
    ip: string;
    port?: number;
    password: string;
}

interface ClientEvents {
    "connected": () => void;
    "message": (message: Message) => void;
    "error": (error: any) => void;
    "disconnected": () => void;
}
declare class Client extends EventEmitter {
    ws: WebSocket | null;
    server: ServerManager;
    players: PlayersManager;
    private connectionOptions;
    private pendingCommands;
    constructor(options: ConnectionOptions);
    on<K extends keyof ClientEvents>(e: K, listener: ClientEvents[K]): this;
    /**
     * Connects to the server
     * @returns {void}
     */
    connect(): void;
    /**
     * Sends a command to the server
     * @param {string} command - The command to be sent
     * @returns {Promise<Message>}
     */
    sendCommand(command: string): Promise<Message>;
    /**
     * Disconnects from the server
     * @returns {void}
     */
    disconnect(): void;
    private onConnection;
    private onMessage;
    private onError;
    private onClose;
    private generateIdentifier;
}

export { type ConnectionOptions, Message, Player, Client as RconConnection, ServerInfo };