erlc-api 3.1.0 → 3.3.0

package/README.md

@@ -1,497 +1,146 @@
 # 🚔 ER:LC API Wrapper
 
-[![npm version](https://badge.fury.io/js/erlc-api.svg)](https://badge.fury.io/js/erlc-api)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://img.shields.io/npm/v/erlc-api?style=flat-square)](https://www.npmjs.com/package/erlc-api)
+[![License](https://img.shields.io/npm/l/erlc-api?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Downloads](https://img.shields.io/npm/dt/erlc-api?style=flat-square)](https://www.npmjs.com/package/erlc-api)
 
-A comprehensive, lightweight, and fully-typed API wrapper for Emergency Response: Liberty County (ER:LC) with 100% API coverage, robust error handling, and TypeScript support.
+Una librería ligera, completa y **totalmente tipada** para interactuar con la API de *Emergency Response: Liberty County* (ER:LC). Diseñada para ofrecer la mejor experiencia de desarrollo tanto en JavaScript como en TypeScript.
 
-## ✨ Features
+---
 
-- 🎯 **100% API Coverage** - All ER:LC API endpoints supported
-- 🛡️ **Robust Error Handling** - Comprehensive error catching and meaningful error messages
-- 📝 **Full TypeScript Support** - Complete type definitions for all methods and responses
-- ⚡ **Optimized Performance** - Efficient request handling with timeout management
-- 🔒 **Secure** - Built-in validation and secure token handling
-- 📚 **Well Documented** - Extensive documentation and examples
-- 🚀 **Easy to Use** - Simple, intuitive API design
+## ✨ Características
 
-## 📦 Installation
+- 🎯 **Cobertura Total**: Soporte para el 100% de los endpoints de la API v1.
+- 🛡️ **Tipado TypeScript**: Definiciones de tipos incluidas nativamente.
+- ⚡ **Ligero y Rápido**: Sin dependencias pesadas innecesarias.
+- 🔒 **Seguro**: Validación de tokens y manejo de errores robusto.
+- 🆕 **Actualizado**: Soporte para `GlobalToken` opcional (v3.2.0+).
 
-```bash
-npm install erlc-api
-```
+## 📦 Instalación
 
 ```bash
+npm install erlc-api
+# o
 bun add erlc-api
 ```
 
-## 🚀 Quick Start
+## 🚀 Inicio Rápido
 
-### Basic Setup
+### Inicialización
 
+Puedes usar la librería con o sin un `Global Token` (requerido solo para aplicaciones a gran escala).
+
+**JavaScript**
 ```javascript
 const erlc = require("erlc-api");
 
-// Initialize the client with your global token
-const client = new erlc.Client({
-  globalToken: "your-global-token-here", // Get this from ER:LC developers
-});
+// Inicialización simple (Recomendada para la mayoría)
+const client = new erlc.Client();
 
-// Register your client
-client.config();
+// O con Global Token (Para Large Apps)
+// const client = new erlc.Client({ globalToken: "..." });
 ```
 
-### TypeScript Setup
-
+**TypeScript**
 ```typescript
-import erlc from "erlc-api";
+import { Client, getServer } from "erlc-api";
 
-const client = new erlc.Client({
-  globalToken: "your-global-token-here",
-});
-
-client.config();
+const client = new Client();
 ```
 
-## 📖 API Methods
-
-### 🖥️ Server Information
+---
 
-#### Get Server Details
+## 📖 Ejemplos de Uso
 
-```javascript
-const getServerInfo = async () => {
-  try {
-    const serverToken = "your-server-api-key"; // From Server Settings
-    const server = await erlc.getServer(serverToken);
-
-    console.log(server);
-    /*
-    Expected Response:
-    {
-      Name: "Your Server Name",
-      OwnerUsername: "ServerOwner",
-      CoOwnerUsernames: ["CoOwner1", "CoOwner2"],
-      CurrentPlayers: 25,
-      MaxPlayers: 40,
-      JoinKey: "ABC123",
-      AccVerifiedReq: "Disabled", // "Email" | "Phone/ID"
-      TeamBalance: true,
-      VanityURL: "https://policeroleplay.community/join?code=ABC123"
-    }
-    */
-  } catch (error) {
-    console.error("Error fetching server info:", error.message);
-  }
-};
-```
+Asegúrate de tener tu `Server Key` a mano (obtenla en los ajustes de tu servidor privado en ER:LC).
 
-#### Get Current Players
+### 🖥️ Información del Servidor
 
 ```javascript
-const getCurrentPlayers = async () => {
-  try {
-    const players = await erlc.getPlayers(serverToken);
-
-    console.log(players);
-    /*
-    Expected Response:
-    [
-      {
-        Player: "PlayerName:123456789",
-        Permission: "Server Owner", // "Member" | "Moderator" | "Server Administrator"
-        Team: "Police" // "Civilian" | "Fire" | "Sheriff"
-      }
-    ]
-    */
-  } catch (error) {
-    console.error("Error fetching players:", error.message);
-  }
-};
-```
+const serverToken = "tu-server-key-aqui";
 
-#### Get Server Queue
+// Obtener estado del servidor
+const server = await erlc.getServer(serverToken);
+console.log(`Servidor: ${server.Name} | Jugadores: ${server.CurrentPlayers}/${server.MaxPlayers}`);
 
-```javascript
-const getServerQueue = async () => {
-  try {
-    const queue = await erlc.getQueue(serverToken);
-    console.log(`Players in queue: ${queue.length}`);
-  } catch (error) {
-    console.error("Error fetching queue:", error.message);
-  }
-};
-```
-
-### 👥 Staff Management
+// Obtener jugadores conectados
+const players = await erlc.getPlayers(serverToken);
+console.table(players); // Muestra nombre, ID, permisos y equipo
 
-#### Get Staff Information
-
-```javascript
-const getStaffInfo = async () => {
-  try {
-    const staff = await erlc.getStaff(serverToken);
-
-    console.log(staff);
-    /*
-    Expected Response:
-    {
-      CoOwners: [123456789, 987654321],
-      Admins: { "123456789": "AdminName" },
-      Mods: { "987654321": "ModName" }
-    }
-    */
-  } catch (error) {
-    console.error("Error fetching staff:", error.message);
-  }
-};
+// Obtener vehículos en el mapa
+const vehicles = await erlc.getVehicles(serverToken);
 ```
 
-### 📊 Server Logs
+### 📜 Registros (Logs)
 
-#### Get Join/Leave Logs
+Accede a los historiales de actividad de tu servidor:
 
 ```javascript
-const getJoinLogs = async () => {
-  try {
-    const logs = await erlc.getJoinLogs(serverToken);
-
-    logs.forEach((log) => {
-      const action = log.Join ? "joined" : "left";
-      console.log(
-        `${log.Player} ${action} at ${new Date(log.Timestamp * 1000)}`
-      );
-    });
-  } catch (error) {
-    console.error("Error fetching join logs:", error.message);
-  }
-};
-```
+// Logs de Entradas/Salidas
+const joinLogs = await erlc.getJoinLogs(serverToken);
 
-#### Get Kill Logs
+// Logs de Muertes (Killfeed)
+const killLogs = await erlc.getKillLogs(serverToken);
 
-```javascript
-const getKillLogs = async () => {
-  try {
-    const kills = await erlc.getKillLogs(serverToken);
-
-    kills.forEach((kill) => {
-      console.log(
-        `${kill.Killer} killed ${kill.Killed} at ${new Date(
-          kill.Timestamp * 1000
-        )}`
-      );
-    });
-  } catch (error) {
-    console.error("Error fetching kill logs:", error.message);
-  }
-};
-```
+// Logs de Comandos ejecutados
+const commandLogs = await erlc.getCommandLogs(serverToken);
 
-#### Get Command Logs
-
-```javascript
-const getCommandLogs = async () => {
-  try {
-    const commands = await erlc.getCommandLogs(serverToken);
-
-    commands.forEach((cmd) => {
-      console.log(`${cmd.Player} executed: ${cmd.Command}`);
-    });
-  } catch (error) {
-    console.error("Error fetching command logs:", error.message);
-  }
-};
-```
-
-#### Get Moderator Call Logs
-
-```javascript
-const getModCalls = async () => {
-  try {
-    const modcalls = await erlc.getModcallLogs(serverToken);
-
-    modcalls.forEach((call) => {
-      const status = call.Moderator
-        ? `answered by ${call.Moderator}`
-        : "unanswered";
-      console.log(`${call.Caller} made a modcall - ${status}`);
-    });
-  } catch (error) {
-    console.error("Error fetching modcall logs:", error.message);
-  }
-};
+// Logs de Llamadas a Moderadores
+const modCalls = await erlc.getModcallLogs(serverToken);
 ```
 
-### 🚗 Vehicle Management
-
-#### Get Server Vehicles
+### 🛠️ Gestión y Administración
 
 ```javascript
-const getVehicles = async () => {
-  try {
-    const vehicles = await erlc.getVehicles(serverToken);
-
-    vehicles.forEach((vehicle) => {
-      console.log(
-        `${vehicle.Name} owned by ${vehicle.Owner} - Texture: ${
-          vehicle.Texture || "Default"
-        }`
-      );
-    });
-  } catch (error) {
-    console.error("Error fetching vehicles:", error.message);
-  }
-};
-```
+// Ver lista de Baneos
+const bans = await erlc.getBans(serverToken);
 
-### 🔨 Server Management
+// Obtener Staff del servidor
+const staff = await erlc.getStaff(serverToken);
 
-#### Execute Server Commands
+// Ejecutar comando remoto (Ej: Anuncio)
+await erlc.runCommand(serverToken, ":h ¡Hola desde la API!");
 
-```javascript
-const executeCommand = async () => {
-  try {
-    const success = await erlc.runCommand(
-      serverToken,
-      ":h Welcome to our server!"
-    );
-
-    if (success) {
-      console.log("Command executed successfully!");
-    }
-  } catch (error) {
-    console.error("Error executing command:", error.message);
-  }
-};
+// Resetear Global Key (Solo si tienes una configurada)
+// await erlc.resetGlobalKey();
 ```
 
-#### Get Server Bans
-
-```javascript
-const getBannedPlayers = async () => {
-  try {
-    const bans = await erlc.getBans(serverToken);
-
-    Object.entries(bans).forEach(([playerId, playerName]) => {
-      console.log(`${playerName} (${playerId}) is banned`);
-    });
-  } catch (error) {
-    console.error("Error fetching bans:", error.message);
-  }
-};
-```
-
-## 🛠️ Advanced Usage
-
-### Error Handling Best Practices
-
-```javascript
-const handleApiCall = async () => {
-  try {
-    const result = await erlc.getServer(serverToken);
-    return result;
-  } catch (error) {
-    // The error is now an ErlcError with detailed information
-    console.error(`Error ${error.code}: ${error.message}`);
-    console.error(`Category: ${error.category}, Severity: ${error.severity}`);
-
-    // Handle specific ERLC error codes
-    switch (error.code) {
-      case 2002:
-        console.error(
-          "Invalid server key - get a new one from server settings"
-        );
-        break;
-      case 4001:
-        console.error("Rate limited - reduce request frequency");
-        break;
-      case 3002:
-        console.error("Server offline - wait for players to join");
-        break;
-      case 9999:
-        console.error("Server module outdated - restart server");
-        break;
-    }
-
-    // Show suggested actions
-    if (error.suggestions) {
-      console.error("Suggested actions:");
-      error.suggestions.forEach((action) => console.error(`- ${action}`));
-    }
-
-    // Check if error is retryable
-    if (error.retryable) {
-      console.error("This error might be resolved by retrying");
-    }
-
-    throw error; // Re-throw if needed
-  }
-};
-```
-
-### Batch Operations
-
-```javascript
-const getServerOverview = async (serverToken) => {
-  try {
-    // Execute multiple API calls concurrently
-    const [serverInfo, players, staff, vehicles] = await Promise.all([
-      erlc.getServer(serverToken),
-      erlc.getPlayers(serverToken),
-      erlc.getStaff(serverToken),
-      erlc.getVehicles(serverToken),
-    ]);
-
-    return {
-      server: serverInfo,
-      playerCount: players.length,
-      staffCount:
-        Object.keys(staff.Admins).length + Object.keys(staff.Mods).length,
-      vehicleCount: vehicles.length,
-    };
-  } catch (error) {
-    console.error("Error getting server overview:", error.message);
-    throw error;
-  }
-};
-```
-
-## 🔑 Authentication
-
-### Getting Your Tokens
-
-1. **Global Token**: Contact ER:LC developers through their [Discord](https://discord.gg/prc) to request increased API limits
-2. **Server Token**: Found in your server settings within ER:LC
-
-### Token Security
-
-```javascript
-// ❌ Don't hardcode tokens
-const client = new erlc.Client({
-  globalToken: "your-token-here",
-});
-
-// ✅ Use environment variables
-const client = new erlc.Client({
-  globalToken: process.env.ERLC_GLOBAL_TOKEN,
-});
-```
-
-## 📝 TypeScript Support
-
-The package includes comprehensive TypeScript definitions:
-
-```typescript
-import erlc, { ServerStatus, ServerPlayer, JoinLog } from "erlc-api";
-
-const client = new erlc.Client({
-  globalToken: process.env.ERLC_GLOBAL_TOKEN!,
-});
-
-client.config();
-
-// Fully typed responses
-const server: ServerStatus = await erlc.getServer(serverToken);
-const players: ServerPlayer[] = await erlc.getPlayers(serverToken);
-const joinLogs: JoinLog[] = await erlc.getJoinLogs(serverToken);
-```
-
-## ⚡ Performance Tips
-
-1. **Use Promise.all()** for concurrent requests when fetching multiple endpoints
-2. **Implement caching** for frequently accessed data that doesn't change often
-3. **Handle rate limits** by implementing retry logic with exponential backoff
-4. **Use timeouts** - all methods have built-in 10-15 second timeouts
-
-## 🐛 Error Types
-
-The wrapper provides comprehensive error handling with specific ERLC error codes:
-
-### ERLC Error Codes
-
-| Code | Category             | Description                            |
-| ---- | -------------------- | -------------------------------------- |
-| 0    | System Error         | Unknown error occurred                 |
-| 1001 | Communication Error  | Error communicating with Roblox server |
-| 1002 | System Error         | Internal system error                  |
-| 2000 | Authentication Error | Missing server key                     |
-| 2001 | Authentication Error | Invalid server key format              |
-| 2002 | Authentication Error | Invalid or expired server key          |
-| 2003 | Authentication Error | Invalid global API key                 |
-| 2004 | Authentication Error | Server key banned                      |
-| 3001 | Request Error        | Invalid command provided               |
-| 3002 | Request Error        | Server offline (no players)            |
-| 4001 | Rate Limit Error     | Rate limited                           |
-| 4002 | Permission Error     | Restricted command                     |
-| 4003 | Content Error        | Prohibited message                     |
-| 9998 | Access Error         | Restricted resource                    |
-| 9999 | Version Error        | Outdated server module                 |
-
-### Error Properties
-
-All errors are instances of `ErlcError` with these properties:
+---
 
-- `code`: ERLC error code or HTTP status
-- `message`: Human-readable error message
-- `category`: Error category (e.g., "AUTHENTICATION_ERROR")
-- `severity`: Error severity ("LOW", "MEDIUM", "HIGH", "CRITICAL")
-- `suggestions`: Array of suggested actions to resolve the error
-- `retryable`: Boolean indicating if the error might be resolved by retrying
-- `timestamp`: ISO timestamp when the error occurred
+## 🚨 Manejo de Errores
 
-### Retry Logic Example
+La librería lanza errores descriptivos (`ErlcError`) que facilitan la depuración.
 
 ```javascript
-async function withRetry(apiCall, maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await apiCall();
-    } catch (error) {
-      if (!error.retryable || attempt === maxRetries) {
-        throw error;
-      }
-
-      // Wait before retrying with exponential backoff
-      const delay = 1000 * Math.pow(2, attempt - 1);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  }
+try {
+  await erlc.getServer(serverToken);
+} catch (error) {
+  console.error(`Error ${error.code}: ${error.message}`);
+  
+  if (error.code === 4001) console.log("⏳ Rate limit alcanzado, espera un momento.");
+  if (error.code === 2002) console.log("🔑 La Server Key es inválida o expiró.");
 }
-
-// Usage
-const players = await withRetry(() => erlc.getPlayers(serverToken));
 ```
 
-## 🤝 Contributing
+### Códigos Comunes
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+| Código | Significado | Solución |
+|:---:|---|---|
+| **2002** | Key Inválida | Verifica tu `Server-Key` en el juego. |
+| **3002** | Servidor Offline | El servidor no tiene jugadores o está apagado. |
+| **4001** | Rate Limit | Estás enviando muchas peticiones muy rápido. |
+| **403** | No Autorizado | Verifica tus permisos o tokens. |
 
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🔗 Links
-
-- **Discord Bot**: [Invite to your server](https://discord.com/oauth2/authorize?client_id=1014990793280323624)
-- **API Documentation**: [PRC API Docs](https://apidocs.policeroleplay.community/reference/api-reference)
-- **Discord Support**: [Join PRC Discord](https://discord.gg/prc)
-- **Custom Liveries**: [Browse Collection](https://github.com/Exodo0/ERLC-API/tree/main/Custom%20Liveries)
+---
 
-## 👨‍💻 Credits
+## 🔗 Enlaces Útiles
 
-- **Library Development**: [Egologics](https://twitter.com/0Adexus0)
-- **NPM Package**: [ERLC-API](https://www.npmjs.com/package/erlc-api)
-- **API Development**: [Police Roleplay Community](https://twitter.com/PRC_Roblox)
-- **Community Support**: [PRC Discord Community](https://discord.gg/prc)
+- [Documentación Oficial de PRC](https://apidocs.policeroleplay.community/)
+- [Discord de Soporte PRC](https://discord.gg/prc)
+- [NPM Package](https://www.npmjs.com/package/erlc-api)
 
 ---
 
 <div align="center">
-  <p>Made with ❤️ for the ER:LC community</p>
-  <p>
-    <a href="https://github.com/Exodo0/ERLC-API">⭐ Star us on GitHub</a> •
-    <a href="https://discord.gg/prc">💬 Join our Discord</a> •
-    <a href="https://twitter.com/0Adexus0">🐦 Follow on Twitter</a>
-  </p>
+  <sub>Hecho con ❤️ para la comunidad de ER:LC</sub>
 </div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erlc-api",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "An ER:LC API wrapper for JS/TS",
   "main": "index.js",
   "types": "src/types/index.d.ts",

package/src/classes/client.js

@@ -1,5 +1,5 @@
-const erlc = require('../erlc.js')
-const assert = require('../functions/assert.js')
+const erlc = require("../erlc.js");
+const assert = require("../functions/assert.js");
 
 /**
  * @typedef {Object} ClientConfig
@@ -13,24 +13,27 @@ const assert = require('../functions/assert.js')
  */
 
 class Client {
-
-    /**
-     * @constructor
-     * @param {ClientConfig} options - Client Options
-     */
-    constructor(options) {
-        assert(typeof options === 'object', `Syntax error: object expected for "options", received ${typeof options}`);
-        this.options = { ...options };
-      }
-    
-     /**
-     * Updates and returns the client configurationg
-     * @returns {ClientConfig} The client configuration.
-     */
-    config() {
-        erlc.config = this.options
-        return erlc.config
+  /**
+   * @constructor
+   * @param {ClientConfig} options - Client Options
+   */
+  constructor(options = {}) {
+    if (options && typeof options === "object") {
+      this.options = { ...options };
+    } else {
+      this.options = {};
     }
+    this.config();
+  }
+
+  /**
+   * Updates and returns the client configurationg
+   * @returns {ClientConfig} The client configuration.
+   */
+  config() {
+    erlc.config = this.options;
+    return erlc.config;
+  }
 }
 
-module.exports = Client
+module.exports = Client;

package/src/erlc.js

@@ -11,5 +11,6 @@ exports.getQueue = require("./functions/server/getQueue.js");
 exports.runCommand = require("./functions/server/runCommand.js");
 exports.getVehicles = require("./functions/server/getVehicles.js");
 exports.getStaff = require("./functions/server/getStaff.js");
+exports.resetGlobalKey = require("./functions/global/resetGlobalKey.js");
 
 exports.Client = require("./classes/client.js");

package/src/functions/global/resetGlobalKey.js

@@ -0,0 +1,60 @@
+const { BASEURL } = require("../../constants.js");
+const { processError } = require("../../utils/errorHandler.js");
+
+/**
+ * Resets the global API key
+ * @returns {Promise<string>} Promise that resolves to the new global API key
+ */
+module.exports = () => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const fetch = await import("node-fetch");
+      const { config } = await import("../../erlc.js");
+
+      // Check if global token is configured
+      if (!config?.globalToken) {
+        const error = await processError(
+          new Error(
+            "Global token not configured. Please initialize the client first."
+          )
+        );
+        return reject(error);
+      }
+
+      const res = await fetch.default(`${BASEURL}/api-key/reset`, {
+        method: "POST",
+        headers: {
+          Authorization: config.globalToken,
+        },
+        timeout: 10000, // 10 second timeout
+      });
+
+      if (!res.ok) {
+        const errorData = await res
+          .json()
+          .catch(() => ({ error: "Unknown API error" }));
+        const error = await processError(res, errorData);
+        return reject(error);
+      }
+
+      // The response is likely a JSON with the new key, or just the key string?
+      // Docs say: "This will send a new key which can only be viewed once."
+      // Let's assume it returns a JSON object or just the string.
+      // Usually these APIs return a JSON object like { "key": "..." } or similar.
+      // However, looking at other endpoints, they return data directly.
+      // Let's assume it returns a JSON with the key, or we can inspect the response content type.
+      // But for now, let's try to parse as JSON.
+      
+      const data = await res.json();
+      // If data has a specific field for the key, we should return that.
+      // If the documentation doesn't specify, I'll return the whole data object or try to find the key.
+      // Based on "This will send a new key", it might be { "apiKey": "..." } or just the string if it's text/plain.
+      // Given other endpoints return JSON, this likely returns JSON.
+      
+      resolve(data);
+    } catch (error) {
+      const processedError = await processError(error);
+      reject(processedError);
+    }
+  });
+};

package/src/functions/server/getBans.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/bans`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getCommandLogs.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/commandlogs`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getJoinLogs.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/joinlogs`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getKillLogs.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/killlogs`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getModcallLogs.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/modcalls`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getPlayers.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/players`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getQueue.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/queue`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getServer.js

@@ -12,20 +12,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        return reject(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server`, {
-        headers: {
-          Authorization: config?.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getStaff.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/staff`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/getVehicles.js

@@ -17,21 +17,15 @@ module.exports = (serverToken) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
+      const headers = {
+        "Server-Key": serverToken,
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
       }
 
       const res = await fetch.default(`${BASEURL}/server/vehicles`, {
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-        },
+        headers: headers,
         timeout: 10000, // 10 second timeout
       });
 

package/src/functions/server/runCommand.js

@@ -26,25 +26,19 @@ module.exports = (serverToken, command) => {
       const fetch = await import("node-fetch");
       const { config } = await import("../../erlc.js");
 
-      // Check if global token is configured
-      if (!config?.globalToken) {
-        const error = await processError(
-          new Error(
-            "Global token not configured. Please initialize the client first."
-          )
-        );
-        return reject(error);
-      }
-
       const requestBody = JSON.stringify({ command: command.trim() });
 
+      const headers = {
+        "Server-Key": serverToken,
+        "Content-Type": "application/json",
+      };
+      if (config?.globalToken) {
+        headers["Authorization"] = config.globalToken;
+      }
+
       const res = await fetch.default(`${BASEURL}/server/command`, {
         method: "POST",
-        headers: {
-          Authorization: config.globalToken,
-          "Server-Key": serverToken,
-          "Content-Type": "application/json",
-        },
+        headers: headers,
         body: requestBody,
         timeout: 15000, // 15 second timeout for commands
       });

package/src/types/index.d.ts

@@ -1,127 +1,127 @@
-declare module "erlc-api" {
-  // Error handling types
-  export class ErlcError extends Error {
-    code: string | number;
-    status?: number;
-    category?: string;
-    severity?: string;
-    suggestions?: string[];
-    retryable?: boolean;
-    timestamp: string;
-    originalError?: Error;
-
-    constructor(
-      message: string,
-      code: string | number,
-      status?: number,
-      originalError?: Error
-    );
-    toJSON(): object;
-    toString(): string;
-  }
-
-  export interface ErrorInfo {
-    message: string;
-    description: string;
-    category: string;
-    severity: string;
-    code?: number;
-  }
-
-  export interface ClientConfig {
-    globalToken: string; // The ER:LC global API token
-  }
-
-  export const BASEURL = "https://api.policeroleplay.community/v1";
-
-  type PlayerId = string;
-  type PlayerName = string;
-  type TextureName = string;
-  type CarName = string;
-
-  export type ErlcPlayer = `${PlayerName}:${PlayerId}`; // Playername:UserID
-  export type ErlcPlayerPermission =
-    | "Normal"
-    | "Server Administrator"
-    | "Server Owner"
-    | "Server Moderator";
-
-  export interface ServerStatus {
-    Name: string; // The server name
-    OwnerUsername: string; // The username of the server owner
-    CoOwnerUsernames: string[]; // The usernames of the server co owners
-    CurrentPlayers: number; // The amount of people currently in-game
-    MaxPlayers: number; // The amount of people who can join the server including server owner
-    JoinKey: string; // The code used to join the private server
-    AccVerifiedReq: "Disabled" | "Email" | "Phone/ID"; // The level of verification roblox accounts need to join the private server
-    TeamBalance: boolean; // If team balance is enabled or not
-    VanityURL: string; // The vanity URL to join the server
-  }
-
-  export interface ServerPlayer {
-    Player: ErlcPlayer;
-    Permission: ErlcPlayerPermission;
-  }
-
-  export interface JoinLog {
-    Join: boolean; // True is join and False is leave
-    Timestamp: number; // Timestamp in seconds
-    Player: ErlcPlayer;
-  }
-
-  export interface KillLog {
-    Killed: ErlcPlayer;
-    Timestamp: number; // Timestamp in seconds
-    Killer: ErlcPlayer;
-  }
-
-  export interface CommandLog {
-    Player: ErlcPlayer;
-    Timestamp: number; // Timestamp in seconds
-    Command: string;
-  }
-
-  export interface ModcallLog {
-    Caller: ErlcPlayer;
-    Moderator?: ErlcPlayer; // If call is unanswered property is undefined
-    Timestamp: number; // Timestamp in seconds
-  }
-
-  export type ServerBan = Record<PlayerId, PlayerName>;
-
-  export interface VehiclesLog {
-    Texture: string | null;
-    Name: string;
-    Owner: ErlcPlayer;
-  }
-
-  export interface ServerStaff {
-    CoOwners: number[];
-    Admins: Record<string, string>;
-    Mods: Record<string, string>;
-  }
-
-  export interface VSMCommandBody {
-    command: string; // ":h Hey everyone!"
-  }
-
-  export function getBans(serverToken: string): Promise<ServerBan>;
-  export function getCommandLogs(serverToken: string): Promise<CommandLog[]>;
-  export function getJoinLogs(serverToken: string): Promise<JoinLog[]>;
-  export function getKillLogs(serverToken: string): Promise<KillLog[]>;
-  export function getModcallLogs(serverToken: string): Promise<ModcallLog[]>;
-  export function getPlayers(serverToken: string): Promise<ServerPlayer[]>;
-  export function getQueue(serverToken: string): Promise<number[]>;
-  export function getServer(serverToken: string): Promise<ServerStatus>;
-  export function getStaff(serverToken: string): Promise<ServerStaff>;
-  export function getVehicles(serverToken: string): Promise<VehiclesLog[]>;
-  export function runCommand(
-    serverToken: string,
-    command: string
-  ): Promise<boolean>;
-
-  export class Client {
-    constructor(options: ClientConfig);
-    config(): ClientConfig;
-  }
+// Error handling types
+export class ErlcError extends Error {
+  code: string | number;
+  status?: number;
+  category?: string;
+  severity?: string;
+  suggestions?: string[];
+  retryable?: boolean;
+  timestamp: string;
+  originalError?: Error;
+
+  constructor(
+    message: string,
+    code: string | number,
+    status?: number,
+    originalError?: Error,
+  );
+  toJSON(): object;
+  toString(): string;
+}
+
+export interface ErrorInfo {
+  message: string;
+  description: string;
+  category: string;
+  severity: string;
+  code?: number;
+}
+
+export interface ClientConfig {
+  globalToken?: string; // The ER:LC global API token
+}
+
+export const BASEURL = "https://api.policeroleplay.community/v1";
+
+type PlayerId = string;
+type PlayerName = string;
+type TextureName = string;
+type CarName = string;
+
+export type ErlcPlayer = `${PlayerName}:${PlayerId}`; // Playername:UserID
+export type ErlcPlayerPermission =
+  | "Normal"
+  | "Server Administrator"
+  | "Server Owner"
+  | "Server Moderator";
+
+export interface ServerStatus {
+  Name: string; // The server name
+  OwnerUsername: string; // The username of the server owner
+  CoOwnerUsernames: string[]; // The usernames of the server co owners
+  CurrentPlayers: number; // The amount of people currently in-game
+  MaxPlayers: number; // The amount of people who can join the server including server owner
+  JoinKey: string; // The code used to join the private server
+  AccVerifiedReq: "Disabled" | "Email" | "Phone/ID"; // The level of verification roblox accounts need to join the private server
+  TeamBalance: boolean; // If team balance is enabled or not
+  VanityURL: string; // The vanity URL to join the server
+}
+
+export interface ServerPlayer {
+  Player: ErlcPlayer;
+  Permission: ErlcPlayerPermission;
+}
+
+export interface JoinLog {
+  Join: boolean; // True is join and False is leave
+  Timestamp: number; // Timestamp in seconds
+  Player: ErlcPlayer;
+}
+
+export interface KillLog {
+  Killed: ErlcPlayer;
+  Timestamp: number; // Timestamp in seconds
+  Killer: ErlcPlayer;
+}
+
+export interface CommandLog {
+  Player: ErlcPlayer;
+  Timestamp: number; // Timestamp in seconds
+  Command: string;
+}
+
+export interface ModcallLog {
+  Caller: ErlcPlayer;
+  Moderator?: ErlcPlayer; // If call is unanswered property is undefined
+  Timestamp: number; // Timestamp in seconds
+}
+
+export type ServerBan = Record<PlayerId, PlayerName>;
+
+export interface VehiclesLog {
+  Texture: string | null;
+  Name: string;
+  Owner: ErlcPlayer;
+}
+
+export interface ServerStaff {
+  CoOwners: number[];
+  Admins: Record<string, string>;
+  Mods: Record<string, string>;
+}
+
+export interface VSMCommandBody {
+  command: string; // ":h Hey everyone!"
+}
+
+export function getBans(serverToken: string): Promise<ServerBan>;
+export function getCommandLogs(serverToken: string): Promise<CommandLog[]>;
+export function getJoinLogs(serverToken: string): Promise<JoinLog[]>;
+export function getKillLogs(serverToken: string): Promise<KillLog[]>;
+export function getModcallLogs(serverToken: string): Promise<ModcallLog[]>;
+export function getPlayers(serverToken: string): Promise<ServerPlayer[]>;
+export function getQueue(serverToken: string): Promise<number[]>;
+export function getServer(serverToken: string): Promise<ServerStatus>;
+export function getStaff(serverToken: string): Promise<ServerStaff>;
+export function getVehicles(serverToken: string): Promise<VehiclesLog[]>;
+export function runCommand(
+  serverToken: string,
+  command: string,
+): Promise<boolean>;
+
+export function resetGlobalKey(): Promise<any>;
+
+export class Client {
+  constructor(options: ClientConfig);
+  config(): ClientConfig;
 }