@erlcjs/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1324 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Base: () => Base,
+  Client: () => Client18,
+  CommandLog: () => CommandLog,
+  CommandLogManager: () => CommandLogManager,
+  CommandManager: () => CommandManager,
+  ERLCEvents: () => ERLCEvents,
+  EmergencyCall: () => EmergencyCall,
+  EmergencyCallManager: () => EmergencyCallManager,
+  InvalidServerKeyError: () => InvalidServerKeyError,
+  KillLog: () => KillLog,
+  KillLogManager: () => KillLogManager,
+  ModCall: () => ModCall,
+  ModCallManager: () => ModCallManager,
+  Player: () => Player,
+  PlayerManager: () => PlayerManager,
+  RestManager: () => RestManager,
+  Server: () => Server,
+  ServerManager: () => ServerManager,
+  Vehicle: () => Vehicle,
+  VehicleManager: () => VehicleManager,
+  WebhookServer: () => WebhookServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/client.ts
+var import_node_events = require("events");
+
+// src/errors/index.ts
+var InvalidServerKeyError = class extends Error {
+  /**
+   * Creates an instance of InvalidServerKeyError.
+   * @param message - The error message. Defaults to 'Invalid Server API Key.'.
+   */
+  constructor(message = "Invalid Server API Key.") {
+    super(message);
+    this.name = "InvalidServerKeyError";
+  }
+};
+
+// src/rest/manager.ts
+var RestManager = class {
+  /**
+   * Creates an instance of RestManager.
+   * @param options - The ClientOptions configuration.
+   */
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  queue = [];
+  processing = false;
+  rateLimitReset = 0;
+  baseUrl = "https://api.erlc.gg";
+  /**
+   * 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.
+   */
+  async request(method, endpoint, body) {
+    console.log(method, endpoint, body);
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          if (Date.now() < this.rateLimitReset) {
+            const waitTime = this.rateLimitReset - Date.now();
+            await new Promise((res) => setTimeout(res, waitTime));
+          }
+          const response = await fetch(`${this.baseUrl}${endpoint}`, {
+            method,
+            headers: {
+              "Server-Key": this.options.serverKey,
+              "Content-Type": "application/json",
+              ...this.options.globalKey && { "Authorization": `Bearer ${this.options.globalKey}` }
+            },
+            body: body ? JSON.stringify(body) : void 0
+          });
+          const resetHeader = response.headers.get("x-ratelimit-reset");
+          if (resetHeader) {
+            this.rateLimitReset = Date.now() + parseInt(resetHeader) * 1e3;
+          }
+          if (response.status === 403) {
+            throw new InvalidServerKeyError();
+          }
+          if (response.status === 429) {
+            this.queue.unshift(() => this.request(method, endpoint, body).then(resolve).catch(reject));
+            return;
+          }
+          if (!response.ok) {
+            throw new Error(`[ERLC API Error] ${response.status}: ${response.statusText}`);
+          }
+          const data = await response.json();
+          resolve(data);
+        } catch (error) {
+          reject(error);
+        }
+      });
+      this.processQueue();
+    });
+  }
+  /**
+   * Processes the request queue sequentially.
+   */
+  async processQueue() {
+    if (this.processing) return;
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const executeTask = this.queue.shift();
+      if (executeTask) await executeTask();
+    }
+    this.processing = false;
+  }
+};
+
+// src/structures/base.ts
+var Base = class {
+  /**
+   * Creates an instance of the Base class.
+   * @param client - The ERLCApi client instance.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+};
+
+// src/structures/server.ts
+var Server = class extends Base {
+  /**
+   * The name of the server.
+   */
+  name;
+  /**
+   * The UserId of the server owner.
+   */
+  ownerId;
+  /**
+   * Array of UserIds of server co-owners.
+   */
+  coOwnerIds;
+  /**
+   * The current number of players connected to the server.
+   */
+  currentPlayers;
+  /**
+   * The maximum number of players allowed in the server.
+   */
+  maxPlayers;
+  /**
+   * The join key of the server.
+   */
+  joinKey;
+  /**
+   * Account verification requirements for joining.
+   */
+  accVerifiedReq;
+  /**
+   * Whether team balance enforcement is enabled.
+   */
+  teamBalance;
+  /**
+   * The queue of players waiting to join the server.
+   */
+  queue;
+  /**
+   * Creates an instance of Server.
+   * @param client - The ERLCApi client.
+   * @param data - The raw server data to initialize.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the Server instance with new raw data.
+   * @param data - The new raw server data.
+   * @returns This server instance.
+   */
+  _patch(data) {
+    this.name = data.Name;
+    this.ownerId = data.OwnerId;
+    this.coOwnerIds = data.CoOwnerIds;
+    this.currentPlayers = data.CurrentPlayers;
+    this.maxPlayers = data.MaxPlayers;
+    this.joinKey = data.JoinKey;
+    this.accVerifiedReq = data.AccVerifiedReq;
+    this.teamBalance = data.TeamBalance;
+    this.queue = data.Queue ?? [];
+    return 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) {
+    return this.name === data.Name && this.ownerId === data.OwnerId && this.coOwnerIds === data.CoOwnerIds && this.currentPlayers === data.CurrentPlayers && this.maxPlayers === data.MaxPlayers && this.joinKey === data.JoinKey && this.accVerifiedReq === data.AccVerifiedReq && this.teamBalance === data.TeamBalance && this.queue === data.Queue;
+  }
+  /**
+   * Converts this Server instance back to its raw JSON structure.
+   * @returns The raw server data.
+   */
+  toJSON() {
+    return {
+      Name: this.name,
+      OwnerId: this.ownerId,
+      CoOwnerIds: this.coOwnerIds,
+      CurrentPlayers: this.currentPlayers,
+      MaxPlayers: this.maxPlayers,
+      JoinKey: this.joinKey,
+      AccVerifiedReq: this.accVerifiedReq,
+      TeamBalance: this.teamBalance,
+      Queue: this.queue
+    };
+  }
+};
+
+// src/managers/servermanager.ts
+var ServerManager = class {
+  /**
+   * Creates an instance of ServerManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Cached Server structure instance, if fetched.
+   */
+  cache;
+  /**
+   * 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.
+   */
+  async fetch() {
+    const rawServerData = await this.client.rest.request("GET", "/v2/server?Players=true&Vehicles=true&Staff=true&JoinLogs=true&Queue=true&KillLogs=true&CommandLogs=true&ModCalls=true&EmergencyCalls=true");
+    if (this.cache?.compare(rawServerData)) return rawServerData;
+    if (this.cache) {
+      const oldCache = new Server(this.client, this.cache.toJSON());
+      this.cache._patch(rawServerData);
+      this.client.emit("SERVER_UPDATE" /* serverUpdate */, oldCache, this.cache);
+    } else {
+      this.cache = new Server(this.client, rawServerData);
+      this.client.emit("SERVER_CREATE" /* serverCreate */, this.cache);
+    }
+    return rawServerData;
+  }
+};
+
+// src/structures/player.ts
+var Player = class _Player extends Base {
+  /**
+   * The unique UserId of the player.
+   */
+  id;
+  /**
+   * The Roblox username of the player.
+   */
+  username;
+  /**
+   * The in-game team name the player is currently on.
+   */
+  team;
+  /**
+   * The player's callsign, if assigned.
+   */
+  callsign;
+  /**
+   * The current location coordinates and address of the player.
+   */
+  location;
+  /**
+   * The player's server permission role.
+   */
+  permission;
+  /**
+   * The player's current wanted star level.
+   */
+  wantedLevel;
+  /**
+   * Creates an instance of Player.
+   * @param client - The ERLCApi client.
+   * @param data - The raw player data to initialize.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches/updates the player structure with new raw data.
+   * @param data - The new raw player data.
+   * @returns This player instance.
+   */
+  _patch(data) {
+    const splitPlayer = data.Player.split(":");
+    this.id = Number(splitPlayer[1]);
+    this.username = splitPlayer[0];
+    this.team = data.Team;
+    this.callsign = data.Callsign;
+    this.location = {
+      x: data.Location.LocationX,
+      y: data.Location.LocationY,
+      postalCode: data.Location.PostalCode,
+      streetName: data.Location.StreetName,
+      buildingNumber: data.Location.BuildingNumber
+    };
+    this.permission = data.Permission ?? "Normal";
+    this.wantedLevel = data.WantedStars ?? 0;
+    return 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.
+   */
+  async kick(reason = "Kicked by API") {
+    await this.client.commands.execute(`:kick ${this.username} ${reason}`);
+  }
+  /**
+   * 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.
+   */
+  async ban(reason = "Banned by API") {
+    await this.client.commands.execute(`:ban ${this.username} ${reason}`);
+  }
+  /**
+   * Jails the player in the game server.
+   * @returns A promise that resolves when the jail command is sent.
+   */
+  async jail() {
+    await this.client.commands.execute(`:jail ${this.username}`);
+  }
+  /**
+   * Heals the player in the game server.
+   * @returns A promise that resolves when the heal command is sent.
+   */
+  async heal() {
+    await this.client.commands.execute(`:heal ${this.username}`);
+  }
+  /**
+   * Kills the player in-game.
+   * @returns A promise that resolves when the kill command is sent.
+   */
+  async kill() {
+    await this.client.commands.execute(`:kill ${this.username}`);
+  }
+  /**
+   * Helpers the player in-game.
+   * @returns A promise that resolves when the helper command is sent.
+   */
+  async helper() {
+    await this.client.commands.execute(`:helper ${this.username}`);
+  }
+  /**
+   * Unhelpers the player in-game.
+   * @returns A promise that resolves when the unhelper command is sent.
+   */
+  async unhelper() {
+    await this.client.commands.execute(`:helper ${this.username}`);
+  }
+  /**
+   * Mods the player in-game.
+   * @returns A promise that resolves when the mod command is sent.
+   */
+  async mod() {
+    await this.client.commands.execute(`:mod ${this.username}`);
+  }
+  /**
+   * Unmods the player in-game.
+   * @returns A promise that resolves when the unmod command is sent.
+   */
+  async unmod() {
+    await this.client.commands.execute(`:unmod ${this.username}`);
+  }
+  /**
+   * Admins the player in-game.
+   * @returns A promise that resolves when the admin command is sent.
+   */
+  async admin() {
+    await this.client.commands.execute(`:admin ${this.username}`);
+  }
+  /**
+   * Unadmins the player in-game.
+   * @returns A promise that resolves when the unadmin command is sent.
+   */
+  async unadmin() {
+    await this.client.commands.execute(`:unadmin ${this.username}`);
+  }
+  /**
+   * 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.
+   */
+  async tp(player) {
+    const playerId = player instanceof _Player ? player.id : player;
+    await this.client.commands.execute(`:tp ${this.username} ${playerId}`);
+  }
+  /**
+   * Sends a private message to the player.
+   * @param text - The message body.
+   * @returns A promise that resolves when the message command is sent.
+   */
+  async message(text) {
+    await this.client.commands.execute(`:pm ${this.username} ${text}`);
+  }
+  /**
+   * Sends a private message to the player.
+   * @param text - The message body.
+   * @returns A promise that resolves when the message command is sent.
+   */
+  async pm(text) {
+    await this.client.commands.execute(`:pm ${this.username} ${text}`);
+  }
+  /**
+   * Converts this Player instance back into raw data structure.
+   * @returns The raw player data.
+   */
+  toJSON() {
+    return {
+      Player: `${this.username}:${this.id}`,
+      Permission: this.permission,
+      Team: this.team,
+      Callsign: this.callsign,
+      WantedStars: this.wantedLevel,
+      Location: { LocationX: this.location.x, LocationY: this.location.y, PostalCode: this.location.postalCode, StreetName: this.location.streetName, BuildingNumber: this.location.buildingNumber }
+    };
+  }
+};
+
+// src/managers/playermanager.ts
+var PlayerManager = class {
+  /**
+   * Creates an instance of PlayerManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of online Players, keyed by their UserId.
+   */
+  cache = /* @__PURE__ */ new Map();
+  nameToId = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all active players currently in the game server.
+   * Updates the player cache.
+   * @returns A promise resolving to a Map of active Players.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?Players=true");
+    const rawPlayers = rawServer.Players ?? [];
+    return this.updateCache(rawPlayers);
+  }
+  /**
+   * 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) {
+    const activeIds = /* @__PURE__ */ new Set();
+    const activeUsers = /* @__PURE__ */ new Set();
+    for (const rawData of rawPlayers) {
+      const userId = Number(rawData.Player.split(":")[1]);
+      const username = rawData.Player.split(":")[0];
+      activeIds.add(userId);
+      activeUsers.add(username);
+      this.nameToId.set(username, userId);
+      const cachedPlayer = this.cache.get(userId);
+      if (cachedPlayer) {
+        const oldPlayer = new Player(this.client, cachedPlayer.toJSON());
+        cachedPlayer._patch(rawData);
+        this.client.emit("PLAYER_UPDATE" /* playerUpdate */, oldPlayer, cachedPlayer);
+      } else {
+        const newPlayer = new Player(this.client, rawData);
+        this.cache.set(newPlayer.id, newPlayer);
+        this.client.emit("PLAYER_JOIN" /* playerJoin */, newPlayer);
+      }
+    }
+    for (const cachedId of this.cache.keys()) {
+      if (!activeIds.has(cachedId)) {
+        this.client.emit("PLAYER_LEAVE" /* playerLeave */, this.cache.get(cachedId));
+        this.cache.delete(cachedId);
+      }
+    }
+    for (const cachedUser of this.nameToId.keys()) {
+      if (!activeUsers.has(cachedUser)) this.nameToId.delete(cachedUser);
+    }
+    return this.cache;
+  }
+  /**
+   * 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) {
+    if (this.nameToId.has(name)) return this.nameToId.get(name);
+    this.fetchAll().then(() => {
+      return this.nameToId.get(name);
+    });
+  }
+};
+
+// src/managers/commandmanager.ts
+var CommandManager = class {
+  /**
+   * Creates an instance of CommandManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = 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.
+   */
+  async execute(command) {
+    const res = await this.client.rest.request("POST", "/v2/server/command", { command });
+    return res;
+  }
+};
+
+// src/gateway/webhookserver.ts
+var import_node_http = require("http");
+var WebhookServer = class {
+  /**
+   * Creates an instance of WebhookServer.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+    this.server = (0, import_node_http.createServer)((req, res) => {
+      const configPath = this.client.options.webhook?.path || "/";
+      if (req.method === "POST" && req.url === configPath) {
+        let body = "";
+        req.on("data", (chunk) => body += chunk);
+        req.on("end", () => {
+          try {
+            const payload = JSON.parse(body);
+            this.handleGatewayEvent(payload);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ received: true }));
+          } catch (err) {
+            res.writeHead(400).end("Malformed Payload");
+          }
+        });
+      } else {
+        res.writeHead(404).end();
+      }
+    });
+  }
+  client;
+  server;
+  /**
+   * Starts listening for incoming webhook events.
+   */
+  listen() {
+    const port = this.client.options.webhook?.port || 3e3;
+    this.server.listen(port, () => {
+    });
+  }
+  /**
+   * Internally processes gateway event payload.
+   * @param payload - Raw JSON payload received.
+   */
+  handleGatewayEvent(payload) {
+  }
+};
+
+// src/structures/vehicle.ts
+var Vehicle = class extends Base {
+  /**
+   * The name/model of the vehicle.
+   */
+  name;
+  /**
+   * The UserId of the vehicle owner.
+   */
+  ownerId;
+  /**
+   * The username of the vehicle owner.
+   */
+  ownerUsername;
+  /**
+   * The Player instance representing the owner, if they are currently online.
+   */
+  owner;
+  /**
+   * The license plate text of the vehicle.
+   */
+  plate;
+  /**
+   * The custom texture identifier, if any.
+   */
+  texture;
+  /**
+   * The hexadecimal color code of the vehicle.
+   */
+  colorHex;
+  /**
+   * The user-friendly color name of the vehicle.
+   */
+  colorName;
+  /**
+   * Creates an instance of Vehicle.
+   * @param client - The ERLCApi client.
+   * @param data - The raw vehicle data to initialize.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the Vehicle structure with new raw data.
+   * @param data - The new raw vehicle data.
+   * @returns This vehicle instance.
+   */
+  _patch(data) {
+    this.name = data.Name;
+    this.ownerUsername = data.Owner;
+    this.ownerId = this.client.players.getIdFromName(this.ownerUsername);
+    this.owner = this.client.players.cache.get(this.ownerId);
+    this.plate = data.Plate;
+    this.texture = data.Texture;
+    this.colorHex = data.ColorHex;
+    this.colorName = data.ColorName;
+    return this;
+  }
+  /**
+   * Converts this Vehicle instance to raw JSON representation.
+   * @returns The raw vehicle data.
+   */
+  toJSON() {
+    return {
+      Name: this.name,
+      Owner: this.ownerUsername,
+      Plate: this.plate,
+      ColorHex: this.colorHex,
+      Texture: this.texture,
+      ColorName: this.colorName
+    };
+  }
+};
+
+// src/managers/vehiclemanager.ts
+var VehicleManager = class {
+  /**
+   * Creates an instance of VehicleManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of spawned vehicles in the server, keyed by their license plate.
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all active vehicles currently spawned in the game server.
+   * Updates the vehicle cache.
+   * @returns A promise resolving to a Map of active Vehicles.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?Vehicles=true");
+    const rawVehicles = rawServer.Vehicles ?? [];
+    return this.updateCache(rawVehicles);
+  }
+  /**
+   * 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) {
+    const activePlates = /* @__PURE__ */ new Set();
+    for (const rawData of rawVehicles) {
+      const plate = rawData.Plate;
+      activePlates.add(plate);
+      const cachedVehicle = this.cache.get(plate);
+      if (cachedVehicle) {
+        const oldVehicle = new Vehicle(this.client, cachedVehicle.toJSON());
+        cachedVehicle._patch(rawData);
+        this.client.emit("VEHICLE_UPDATE" /* vehicleUpdate */, oldVehicle, cachedVehicle);
+      } else {
+        const newVehicle = new Vehicle(this.client, rawData);
+        this.cache.set(newVehicle.plate, newVehicle);
+        this.client.emit("VEHICLE_ADD" /* vehicleAdd */, newVehicle);
+      }
+    }
+    for (const cachedPlate of this.cache.keys()) {
+      if (!activePlates.has(cachedPlate)) {
+        this.client.emit("VEHICLE_REMOVE" /* vehicleRemove */, this.cache.get(cachedPlate));
+        this.cache.delete(cachedPlate);
+      }
+    }
+    return this.cache;
+  }
+};
+
+// src/structures/commandlog.ts
+var CommandLog = class extends Base {
+  /**
+   * The player instance representing who ran the command.
+   */
+  player;
+  /**
+   * The UserId of the player who ran the command.
+   */
+  playerId;
+  /**
+   * The username of the player who ran the command.
+   */
+  playerUsername;
+  /**
+   * Unix timestamp of when the command was run.
+   */
+  timestamp;
+  /**
+   * The full command string executed.
+   */
+  command;
+  /**
+   * Creates an instance of CommandLog.
+   * @param client - The ERLCApi client.
+   * @param data - The raw command log data to initialize.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the CommandLog structure with new raw data.
+   * @param data - The new raw command log data.
+   * @returns This command log instance.
+   */
+  _patch(data) {
+    const splitPlayer = data.Player.split(":");
+    this.playerId = Number(splitPlayer[1]);
+    this.playerUsername = splitPlayer[0];
+    this.player = this.client.players.cache.get(this.playerId);
+    this.command = data.Command;
+    this.timestamp = data.Timestamp;
+    return this;
+  }
+  /**
+   * Converts this CommandLog instance to raw JSON representation.
+   * @returns The raw command log data.
+   */
+  toJSON() {
+    return {
+      Player: `${this.playerUsername}:${this.playerId}`,
+      Timestamp: this.timestamp,
+      Command: this.command
+    };
+  }
+};
+
+// src/managers/commandlogmanager.ts
+var CommandLogManager = class {
+  /**
+   * Creates an instance of CommandLogManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of logged commands, keyed by a composite `Player:Timestamp` key.
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all command logs from the game server.
+   * Updates the command log cache.
+   * @returns A promise resolving to a Map of CommandLogs.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?CommandLogs=true");
+    const rawCommands = rawServer.CommandLogs ?? [];
+    return this.updateCache(rawCommands);
+  }
+  /**
+   * 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) {
+    for (const rawData of rawCommands) {
+      const key = `${rawData.Player}:${rawData.Timestamp}`;
+      const cachedPlayer = this.cache.get(key);
+      if (!cachedPlayer) {
+        const newCommand = new CommandLog(this.client, rawData);
+        this.cache.set(key, newCommand);
+        this.client.emit("COMMAND" /* command */, newCommand);
+      }
+    }
+    return this.cache;
+  }
+};
+
+// src/structures/emergencycall.ts
+var EmergencyCall = class extends Base {
+  /**
+   * The Player instance representing the caller.
+   */
+  caller;
+  /**
+   * The UserId of the player who made the emergency call.
+   */
+  callerId;
+  /**
+   * The team associated with the emergency call (e.g., "Police", "Fire").
+   */
+  team;
+  /**
+   * Array of UserIds of responders assigned to this call.
+   */
+  playerIds;
+  /**
+   * Array of Player instances of active responders assigned to this call.
+   */
+  players;
+  /**
+   * The game position coordinates [x, y] of the call.
+   */
+  position;
+  /**
+   * Unix timestamp of when the call was started.
+   */
+  startedAt;
+  /**
+   * The unique call number.
+   */
+  callNumber;
+  /**
+   * The description text of the emergency call.
+   */
+  description;
+  /**
+   * Positional description of where the call was made.
+   */
+  positionDescriptor;
+  /**
+   * Creates an instance of EmergencyCall.
+   * @param client - The ERLCApi client.
+   * @param data - The raw emergency call data to initialize.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the EmergencyCall structure with new raw data.
+   * @param data - The new raw emergency call data.
+   * @returns This emergency call instance.
+   */
+  _patch(data) {
+    this.callerId = data.Caller;
+    this.caller = this.client.players.cache.get(this.callerId);
+    this.team = data.Team;
+    this.playerIds = data.Players;
+    this.players = [];
+    for (const playerId of data.Players) {
+      const player = this.client.players.cache.get(playerId);
+      if (player) this.players.push(player);
+    }
+    this.position = data.Position;
+    this.startedAt = data.StartedAt;
+    this.callNumber = data.CallNumber;
+    this.description = data.Description;
+    this.positionDescriptor = data.PositionDescriptor;
+    return this;
+  }
+  /**
+   * Converts this EmergencyCall instance to raw JSON representation.
+   * @returns The raw emergency call data.
+   */
+  toJSON() {
+    return {
+      Caller: this.callerId,
+      Team: this.team,
+      Players: this.playerIds,
+      Position: this.position,
+      StartedAt: this.startedAt,
+      CallNumber: this.callNumber,
+      Description: this.description,
+      PositionDescriptor: this.positionDescriptor
+    };
+  }
+};
+
+// src/managers/emergencycallmanager.ts
+var EmergencyCallManager = class {
+  /**
+   * Creates an instance of EmergencyCallManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of active emergency calls, keyed by call number.
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all active emergency calls from the game server.
+   * Updates the emergency call cache.
+   * @returns A promise resolving to a Map of active EmergencyCalls.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?EmergencyCalls=true");
+    const rawEmergencyCalls = rawServer.EmergencyCalls ?? [];
+    return this.updateCache(rawEmergencyCalls);
+  }
+  /**
+   * 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) {
+    const activeCalls = /* @__PURE__ */ new Set();
+    for (const rawData of rawCalls) {
+      const callNum = rawData.CallNumber;
+      activeCalls.add(callNum);
+      const cachedCall = this.cache.get(callNum);
+      if (cachedCall) {
+        const oldCall = new EmergencyCall(this.client, cachedCall.toJSON());
+        cachedCall._patch(rawData);
+        this.client.emit("EMERGENCY_CALL_UPDATE" /* emergencyCallUpdate */, oldCall, cachedCall);
+      } else {
+        const newCall = new EmergencyCall(this.client, rawData);
+        this.cache.set(newCall.callNumber, newCall);
+        this.client.emit("EMERGENCY_CALL_ADD" /* emergencyCallAdd */, newCall);
+      }
+    }
+    for (const cachedCall of this.cache.keys()) {
+      if (!activeCalls.has(cachedCall)) {
+        this.client.emit("EMERGENCY_CALL_REMOVE" /* emergencyCallRemove */, this.cache.get(cachedCall));
+        this.cache.delete(cachedCall);
+      }
+    }
+    return this.cache;
+  }
+};
+
+// src/structures/killlog.ts
+var KillLog = class extends Base {
+  /**
+   * The Player instance representing the player who was killed.
+   */
+  killed;
+  /**
+   * The UserId of the player who was killed.
+   */
+  killedId;
+  /**
+   * The Roblox username of the player who was killed.
+   */
+  killedUsername;
+  /**
+   * The Player instance representing the player who did the killing.
+   */
+  killer;
+  /**
+   * The UserId of the player who did the killing.
+   */
+  killerId;
+  /**
+   * The Roblox username of the player who did the killing.
+   */
+  killerUsername;
+  /**
+   * Unix timestamp of when the kill occurred.
+   */
+  timestamp;
+  /**
+   * Creates an instance of KillLog.
+   * @param client - The ERLCApi client.
+   * @param data - The raw kill log data.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the KillLog structure with new raw data.
+   * @param data - The new raw kill log data.
+   * @returns This kill log instance.
+   */
+  _patch(data) {
+    const splitKilled = data.Killed.split(":");
+    const splitKiller = data.Killer.split(":");
+    this.killedId = Number(splitKilled[1]);
+    this.killedUsername = splitKilled[0];
+    this.killed = this.client.players.cache.get(this.killedId);
+    this.killerId = Number(splitKiller[1]);
+    this.killerUsername = splitKiller[0];
+    this.killer = this.client.players.cache.get(this.killerId);
+    this.timestamp = data.Timestamp;
+    return this;
+  }
+  /**
+   * Converts this KillLog instance to raw JSON representation.
+   * @returns The raw kill log data.
+   */
+  toJSON() {
+    return {
+      Killed: `${this.killedUsername}:${this.killedId}`,
+      Killer: `${this.killerUsername}:${this.killerId}`,
+      Timestamp: this.timestamp
+    };
+  }
+};
+
+// src/managers/killlogmanager.ts
+var KillLogManager = class {
+  /**
+   * Creates an instance of KillLogManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of logged kills, keyed by a composite `Killer:Killed:Timestamp` key.
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all kill logs from the game server.
+   * Updates the kill log cache.
+   * @returns A promise resolving to a Map of KillLogs.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?KillLogs=true");
+    const rawKillLogs = rawServer.KillLogs ?? [];
+    return this.updateCache(rawKillLogs);
+  }
+  /**
+   * 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) {
+    for (const rawData of rawCommands) {
+      const key = `${rawData.Killer}:${rawData.Killed}:${rawData.Timestamp}`;
+      const cachedPlayer = this.cache.get(key);
+      if (!cachedPlayer) {
+        const newKill = new KillLog(this.client, rawData);
+        this.cache.set(key, newKill);
+        this.client.emit("KILL" /* kill */, newKill);
+      }
+    }
+    return this.cache;
+  }
+};
+
+// src/structures/modcall.ts
+var ModCall = class extends Base {
+  /**
+   * The Player instance representing the caller.
+   */
+  caller;
+  /**
+   * The UserId of the player who made the moderator call.
+   */
+  callerId;
+  /**
+   * The Roblox username of the caller.
+   */
+  callerUsername;
+  /**
+   * Unix timestamp of the moderator call.
+   */
+  timestamp;
+  /**
+   * The Player instance representing the moderator who responded, if any.
+   */
+  moderator;
+  /**
+   * The UserId of the moderator who responded, if any.
+   */
+  moderatorId;
+  /**
+   * The Roblox username of the moderator who responded, if any.
+   */
+  moderatorUsername;
+  /**
+   * Creates an instance of ModCall.
+   * @param client - The ERLCApi client.
+   * @param data - The raw moderator call data.
+   */
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+  /**
+   * Patches the ModCall structure with new raw data.
+   * @param data - The new raw moderator call data.
+   * @returns This moderator call instance.
+   */
+  _patch(data) {
+    const splitCaller = data.Caller.split(":");
+    this.callerId = Number(splitCaller[1]);
+    this.callerUsername = splitCaller[0];
+    this.caller = this.client.players.cache.get(this.callerId);
+    if (data.Moderator) {
+      const splitModerator = data.Moderator.split(":");
+      this.moderatorId = Number(splitModerator[1]);
+      this.moderatorUsername = splitModerator[0];
+      this.moderator = this.client.players.cache.get(this.moderatorId);
+    }
+    this.timestamp = data.Timestamp;
+    return this;
+  }
+  /**
+   * Converts this ModCall instance to raw JSON representation.
+   * @returns The raw moderator call data.
+   */
+  toJSON() {
+    if (this.moderatorId) return {
+      Caller: `${this.callerUsername}:${this.callerId}`,
+      Timestamp: this.timestamp,
+      Moderator: `${this.moderatorUsername}:${this.moderatorId}`
+    };
+    return {
+      Caller: `${this.callerUsername}:${this.callerId}`,
+      Timestamp: this.timestamp
+    };
+  }
+};
+
+// src/managers/modcallmanager.ts
+var ModCallManager = class {
+  /**
+   * Creates an instance of ModCallManager.
+   * @param client - The ERLCApi client.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Map cache of logged moderator calls, keyed by a composite `Caller:Timestamp` key.
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Fetches all moderator calls from the game server.
+   * Updates the moderator call cache.
+   * @returns A promise resolving to a Map of ModCalls.
+   */
+  async fetchAll() {
+    const rawServer = await this.client.rest.request("GET", "/v2/server?ModCalls=true");
+    const rawModCalls = rawServer.ModCalls ?? [];
+    return this.updateCache(rawModCalls);
+  }
+  /**
+   * 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) {
+    for (const rawData of rawCommands) {
+      const key = `${rawData.Caller}:${rawData.Timestamp}`;
+      const cachedPlayer = this.cache.get(key);
+      if (!cachedPlayer) {
+        const newCall = new ModCall(this.client, rawData);
+        this.cache.set(key, newCall);
+        this.client.emit("MOD_CALL" /* modCall */, newCall);
+      }
+    }
+    return this.cache;
+  }
+};
+
+// src/client/client.ts
+var ERLCEvents = /* @__PURE__ */ ((ERLCEvents2) => {
+  ERLCEvents2["poll"] = "POLL";
+  ERLCEvents2["serverUpdate"] = "SERVER_UPDATE";
+  ERLCEvents2["serverCreate"] = "SERVER_CREATE";
+  ERLCEvents2["playerJoin"] = "PLAYER_JOIN";
+  ERLCEvents2["playerUpdate"] = "PLAYER_UPDATE";
+  ERLCEvents2["playerLeave"] = "PLAYER_LEAVE";
+  ERLCEvents2["vehicleAdd"] = "VEHICLE_ADD";
+  ERLCEvents2["vehicleRemove"] = "VEHICLE_REMOVE";
+  ERLCEvents2["vehicleUpdate"] = "VEHICLE_UPDATE";
+  ERLCEvents2["command"] = "COMMAND";
+  ERLCEvents2["modCall"] = "MOD_CALL";
+  ERLCEvents2["kill"] = "KILL";
+  ERLCEvents2["emergencyCallAdd"] = "EMERGENCY_CALL_ADD";
+  ERLCEvents2["emergencyCallRemove"] = "EMERGENCY_CALL_REMOVE";
+  ERLCEvents2["emergencyCallUpdate"] = "EMERGENCY_CALL_UPDATE";
+  return ERLCEvents2;
+})(ERLCEvents || {});
+var Client18 = class extends import_node_events.EventEmitter {
+  /**
+   * Creates an instance of Client.
+   * @param options - The ClientOptions configuration.
+   */
+  constructor(options) {
+    super();
+    this.options = options;
+    this.rest = new RestManager(options);
+    this.server = new ServerManager(this);
+    this.players = new PlayerManager(this);
+    this.commands = new CommandManager(this);
+    this.vehicles = new VehicleManager(this);
+    this.commandLogs = new CommandLogManager(this);
+    this.emergencyCalls = new EmergencyCallManager(this);
+    this.killLogs = new KillLogManager(this);
+    this.modCalls = new ModCallManager(this);
+    if (options.webhook?.enabled) {
+      this.gateway = new WebhookServer(this);
+      this.gateway.listen();
+    }
+    if (options.polling) {
+      this.startPolling();
+    }
+  }
+  options;
+  /** REST Manager for sending manual requests to the ER:LC API. */
+  rest;
+  /** Manager for fetching and caching general server configuration. */
+  server;
+  /** Manager for player caching, joining, and management actions. */
+  players;
+  /** Manager for executing server-side console commands. */
+  commands;
+  /** Manager for spawned vehicles cache and events. */
+  vehicles;
+  /** Manager for command execution log events. */
+  commandLogs;
+  /** Manager for active emergency calls. */
+  emergencyCalls;
+  /** Manager for kill logs. */
+  killLogs;
+  /** Manager for moderator call logs. */
+  modCalls;
+  /** Webhook Gateway server instance, if enabled. */
+  gateway;
+  /**
+   * Starts the periodic api-polling loop if enabled.
+   */
+  startPolling() {
+    console.log("begin polling");
+    setInterval(async () => {
+      try {
+        const server = await this.server.fetch();
+        this.emit("POLL" /* poll */, server);
+        console.log("fetch");
+        if (server.Players) this.players.updateCache(server.Players);
+        if (server.Vehicles) this.vehicles.updateCache(server.Vehicles);
+        if (server.CommandLogs) this.commandLogs.updateCache(server.CommandLogs);
+        if (server.EmergencyCalls) this.emergencyCalls.updateCache(server.EmergencyCalls);
+        if (server.KillLogs) this.killLogs.updateCache(server.KillLogs);
+        if (server.ModCalls) this.modCalls.updateCache(server.ModCalls);
+      } catch (err) {
+        this.emit("error", err);
+      }
+    }, 5e3);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Base,
+  Client,
+  CommandLog,
+  CommandLogManager,
+  CommandManager,
+  ERLCEvents,
+  EmergencyCall,
+  EmergencyCallManager,
+  InvalidServerKeyError,
+  KillLog,
+  KillLogManager,
+  ModCall,
+  ModCallManager,
+  Player,
+  PlayerManager,
+  RestManager,
+  Server,
+  ServerManager,
+  Vehicle,
+  VehicleManager,
+  WebhookServer
+});