@wumx-labs/noxaeapi-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,740 @@
+// src/errors.ts
+var NoxAeApiError = class extends Error {
+  status;
+  method;
+  path;
+  body;
+  constructor(message, info) {
+    super(message);
+    this.name = "NoxAeApiError";
+    this.status = info.status;
+    this.method = info.method;
+    this.path = info.path;
+    this.body = info.body;
+  }
+};
+var NoxAeApiUnauthorizedError = class extends NoxAeApiError {
+  constructor(info) {
+    super(
+      `Unauthorized: the API key was missing or invalid for ${info.method} ${info.path}`,
+      info
+    );
+    this.name = "NoxAeApiUnauthorizedError";
+  }
+};
+var NoxAeApiForbiddenError = class extends NoxAeApiError {
+  constructor(info) {
+    super(
+      `Forbidden: this API key does not have permission to call ${info.method} ${info.path}`,
+      info
+    );
+    this.name = "NoxAeApiForbiddenError";
+  }
+};
+var NoxAeApiNotFoundError = class extends NoxAeApiError {
+  constructor(info) {
+    super(`Not found: ${info.method} ${info.path}`, info);
+    this.name = "NoxAeApiNotFoundError";
+  }
+};
+var NoxAeApiRateLimitError = class extends NoxAeApiError {
+  retryAfterMs;
+  constructor(info, retryAfterMs) {
+    super(
+      `Rate limited on ${info.method} ${info.path}${retryAfterMs ? ` \u2014 retry after ${retryAfterMs}ms` : ""}`,
+      info
+    );
+    this.name = "NoxAeApiRateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var NoxAeApiServerError = class extends NoxAeApiError {
+  constructor(info) {
+    super(`Server error (${info.status}) on ${info.method} ${info.path}`, info);
+    this.name = "NoxAeApiServerError";
+  }
+};
+var NoxAeApiNetworkError = class extends Error {
+  method;
+  path;
+  cause;
+  constructor(message, method, path, cause) {
+    super(message);
+    this.name = "NoxAeApiNetworkError";
+    this.method = method;
+    this.path = path;
+    this.cause = cause;
+  }
+};
+
+// src/http-engine.ts
+var DEFAULT_RETRY = {
+  attempts: 3,
+  baseDelayMs: 300,
+  maxDelayMs: 5e3
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelay(attempt, opts) {
+  const exp = Math.min(opts.maxDelayMs, opts.baseDelayMs * 2 ** attempt);
+  return Math.floor(Math.random() * exp);
+}
+var HttpEngine = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  retry;
+  extraHeaders;
+  fetchImpl;
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("NoxAeApiClient requires a non-empty baseUrl");
+    }
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.retry = options.retry === false ? false : { ...DEFAULT_RETRY, ...options.retry ?? {} };
+    this.extraHeaders = options.headers ?? {};
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new Error(
+        "No fetch implementation available. Pass `fetchImpl` in options for this runtime."
+      );
+    }
+    this.fetchImpl = fetchImpl;
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}/${path.replace(/^\/+/, "")}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(method, path, opts = {}) {
+    const url = this.buildUrl(path, opts.query);
+    const maxAttempts = this.retry ? this.retry.attempts : 1;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const headers = {
+          Accept: "application/json",
+          ...this.extraHeaders
+        };
+        if (this.apiKey) headers["key"] = this.apiKey;
+        if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+        const response = await this.fetchImpl(url, {
+          method,
+          headers,
+          body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+          if (response.status === 204) return void 0;
+          const text = await response.text();
+          return text ? JSON.parse(text) : void 0;
+        }
+        const errorBody = await response.text().catch(() => void 0);
+        const parsedBody = safeJsonParse(errorBody);
+        const info = { status: response.status, method, path, body: parsedBody };
+        if (response.status === 401) throw new NoxAeApiUnauthorizedError(info);
+        if (response.status === 403) throw new NoxAeApiForbiddenError(info);
+        if (response.status === 404) throw new NoxAeApiNotFoundError(info);
+        if (response.status === 429) {
+          const retryAfterHeader = response.headers.get("Retry-After");
+          const retryAfterMs = retryAfterHeader ? parseRetryAfter(retryAfterHeader) : void 0;
+          const err = new NoxAeApiRateLimitError(info, retryAfterMs);
+          if (this.retry && attempt < maxAttempts - 1) {
+            lastError = err;
+            await sleep(retryAfterMs ?? backoffDelay(attempt, this.retry));
+            continue;
+          }
+          throw err;
+        }
+        if (response.status >= 500) {
+          const err = new NoxAeApiServerError(info);
+          if (this.retry && attempt < maxAttempts - 1) {
+            lastError = err;
+            await sleep(backoffDelay(attempt, this.retry));
+            continue;
+          }
+          throw err;
+        }
+        throw new NoxAeApiError(
+          `Unexpected status ${response.status} on ${method} ${path}`,
+          info
+        );
+      } catch (err) {
+        clearTimeout(timeout);
+        if (err instanceof NoxAeApiError) throw err;
+        const isAbort = err instanceof Error && err.name === "AbortError";
+        const networkErr = new NoxAeApiNetworkError(
+          isAbort ? `Request timed out after ${this.timeoutMs}ms: ${method} ${path}` : `Network error on ${method} ${path}: ${err.message}`,
+          method,
+          path,
+          err
+        );
+        if (this.retry && attempt < maxAttempts - 1) {
+          lastError = networkErr;
+          await sleep(backoffDelay(attempt, this.retry));
+          continue;
+        }
+        throw networkErr;
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Request failed after retries");
+  }
+};
+function safeJsonParse(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function parseRetryAfter(headerValue) {
+  const seconds = Number(headerValue);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const date = Date.parse(headerValue);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+
+// src/modules/players.ts
+var PlayersModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** List currently online players. */
+  list() {
+    return this.http.request("GET", "players");
+  }
+  /** List all players the server has ever seen (online + offline). */
+  listAll() {
+    return this.http.request("GET", "players/all");
+  }
+  /** Get a single player by UUID (works for online or offline players). */
+  get(uuid) {
+    return this.http.request("GET", `players/${encodeURIComponent(uuid)}`);
+  }
+  /** Get a player's inventory in a specific world. */
+  getInventory(playerUuid, worldUuid) {
+    return this.http.request(
+      "GET",
+      `players/${encodeURIComponent(playerUuid)}/${encodeURIComponent(worldUuid)}/inventory`
+    );
+  }
+  /** Kick an online player, optionally with a reason. */
+  kick(uuid, reason) {
+    return this.http.request("POST", `players/${encodeURIComponent(uuid)}/kick`, {
+      body: reason ? { reason } : void 0
+    });
+  }
+  /** Ban a player, optionally with a reason and expiration. */
+  ban(uuid, reason) {
+    return this.http.request("POST", `players/${encodeURIComponent(uuid)}/ban`, {
+      body: reason ? { reason } : void 0
+    });
+  }
+  /** Remove a player's ban. */
+  unban(uuid) {
+    return this.http.request("DELETE", `players/${encodeURIComponent(uuid)}/ban`);
+  }
+  /** Teleport a player to a location. */
+  teleport(uuid, location) {
+    return this.http.request("POST", `players/${encodeURIComponent(uuid)}/teleport`, {
+      body: location
+    });
+  }
+  /** Change a player's gamemode. */
+  setGamemode(uuid, gamemode) {
+    return this.http.request("PUT", `players/${encodeURIComponent(uuid)}/gamemode`, {
+      body: { gamemode }
+    });
+  }
+  /** Get kill/death/playtime/block stats for a player. */
+  getStats(uuid) {
+    return this.http.request("GET", `players/${encodeURIComponent(uuid)}/stats`);
+  }
+};
+
+// src/modules/economy.ts
+var EconomyModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Get info about the connected economy provider (Impactor on Fabric, Vault on Bukkit/Spigot/Paper). */
+  info() {
+    return this.http.request("GET", "economy");
+  }
+  /** Get a player's balance. */
+  getBalance(uuid) {
+    return this.http.request("GET", `economy/balance/${encodeURIComponent(uuid)}`);
+  }
+  /** Get the top balances leaderboard. */
+  getTopBalance(limit) {
+    return this.http.request("GET", "economy/top", {
+      query: { limit }
+    });
+  }
+  /** Pay an amount to a player (adds to their balance). */
+  pay(uuid, amount) {
+    return this.http.request("POST", "economy/pay", { body: { uuid, amount } });
+  }
+  /** Debit an amount from a player (subtracts from their balance). */
+  debit(uuid, amount) {
+    return this.http.request("POST", "economy/debit", { body: { uuid, amount } });
+  }
+};
+
+// src/modules/server.ts
+var ServerModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Basic liveness check. */
+  ping() {
+    return this.http.request("GET", "ping");
+  }
+  /** Get server info: version, MOTD, TPS, health, player counts, etc. */
+  info() {
+    return this.http.request("GET", "server");
+  }
+  /**
+   * Run a console command on the server.
+   * This is a privileged endpoint — requires a write-enabled API key.
+   */
+  exec(command) {
+    return this.http.request("POST", "server/exec", { body: { command } });
+  }
+  /** List server operators. */
+  getOps() {
+    return this.http.request("GET", "server/ops");
+  }
+  /** Grant operator status to a player. */
+  opPlayer(uuid) {
+    return this.http.request("POST", "server/ops", { body: { uuid } });
+  }
+  /** Revoke operator status from a player. */
+  deopPlayer(uuid) {
+    return this.http.request("DELETE", "server/ops", { body: { uuid } });
+  }
+  /** Get the current whitelist. */
+  getWhitelist() {
+    return this.http.request("GET", "server/whitelist");
+  }
+  /** Add a player to the whitelist. */
+  addToWhitelist(uuid, name) {
+    return this.http.request("POST", "server/whitelist", { body: { uuid, name } });
+  }
+  /** Remove a player from the whitelist. */
+  removeFromWhitelist(uuid) {
+    return this.http.request("DELETE", "server/whitelist", { body: { uuid } });
+  }
+  /**
+   * Restart the server.
+   * This is a privileged endpoint — requires a write-enabled API key.
+   */
+  restart() {
+    return this.http.request("POST", "server/restart");
+  }
+  /** Tail the server console log. */
+  getLogs(lines) {
+    return this.http.request("GET", "server/logs", { query: { lines } });
+  }
+  /** Get entity counts on the server, optionally scoped to a world. */
+  getEntities(world) {
+    return this.http.request("GET", "server/entities", { query: { world } });
+  }
+  /** Get loaded chunk counts, optionally scoped to a world. */
+  getChunks(world) {
+    return this.http.request("GET", "server/chunks", { query: { world } });
+  }
+  /** Ban an IP address. */
+  banIp(ip, reason) {
+    return this.http.request("POST", "server/ban-ip", { body: { ip, reason } });
+  }
+  /** Get a scoreboard objective's scores by objective name. */
+  getObjective(name) {
+    return this.http.request("GET", `scoreboard/${encodeURIComponent(name)}`);
+  }
+  /** List all scoreboard objectives and tracked entries. */
+  getScoreboard() {
+    return this.http.request("GET", "scoreboard");
+  }
+  /** Set a score for an entry on an objective. */
+  setScore(objective, entry, value) {
+    return this.http.request("POST", `scoreboard/${encodeURIComponent(objective)}/score`, {
+      body: { entry, value }
+    });
+  }
+  /** Reset (remove) a score for an entry on an objective. */
+  resetScore(objective, entry) {
+    return this.http.request("DELETE", `scoreboard/${encodeURIComponent(objective)}/score`, {
+      body: { entry }
+    });
+  }
+  /** Broadcast a message to every player on the server. */
+  broadcast(message) {
+    return this.http.request("POST", "chat/broadcast", { body: { message } });
+  }
+  /** Send a private message to a specific player. */
+  tell(uuid, message) {
+    return this.http.request("POST", "chat/tell", { body: { uuid, message } });
+  }
+};
+
+// src/modules/worlds.ts
+var WorldsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** List all worlds. */
+  list() {
+    return this.http.request("GET", "worlds");
+  }
+  /** Save all worlds to disk. */
+  saveAll() {
+    return this.http.request("POST", "worlds/save");
+  }
+  /** Get a download link/stream reference for all worlds. */
+  downloadAll() {
+    return this.http.request("GET", "worlds/download");
+  }
+  /** Get a single world by UUID. */
+  get(uuid) {
+    return this.http.request("GET", `worlds/${encodeURIComponent(uuid)}`);
+  }
+  /** Save a specific world to disk. */
+  save(uuid) {
+    return this.http.request("POST", `worlds/${encodeURIComponent(uuid)}/save`);
+  }
+  /** Get a download link/stream reference for a specific world. */
+  download(uuid) {
+    return this.http.request("GET", `worlds/${encodeURIComponent(uuid)}/download`);
+  }
+  /** Set the in-game time for a world. */
+  setTime(uuid, time) {
+    return this.http.request("POST", `worlds/${encodeURIComponent(uuid)}/time`, {
+      body: { time }
+    });
+  }
+  /** Set weather (storm/thundering) for a world. */
+  setWeather(uuid, weather) {
+    return this.http.request("POST", `worlds/${encodeURIComponent(uuid)}/weather`, {
+      body: weather
+    });
+  }
+  /** Get entity counts within a specific world. */
+  getEntities(uuid) {
+    return this.http.request("GET", `worlds/${encodeURIComponent(uuid)}/entities`);
+  }
+};
+
+// src/modules/plugins.ts
+var PluginsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** List all installed plugins/mods. */
+  list() {
+    return this.http.request("GET", "plugins");
+  }
+  /**
+   * Install a plugin from a URL or identifier.
+   * This is a privileged endpoint — requires a write-enabled API key.
+   */
+  install(source) {
+    return this.http.request("POST", "plugins", { body: { source } });
+  }
+  /** Enable a plugin by name. */
+  enable(name) {
+    return this.http.request("POST", `plugins/${encodeURIComponent(name)}/enable`);
+  }
+  /** Disable a plugin by name. */
+  disable(name) {
+    return this.http.request("POST", `plugins/${encodeURIComponent(name)}/disable`);
+  }
+};
+
+// src/modules/misc.ts
+var AdvancementsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** List all advancements known to the server. */
+  list() {
+    return this.http.request("GET", "advancements");
+  }
+};
+var PlaceholdersModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Replace PlaceholderAPI-style placeholders (e.g. "%player_name%") for a
+   * player, returning the resolved string.
+   */
+  replace(uuid, text) {
+    return this.http.request("POST", "placeholders/replace", {
+      body: { uuid, text }
+    });
+  }
+};
+
+// src/modules/luckperms.ts
+var LuckPermsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Get the groups a player belongs to. */
+  getPlayerGroups(uuid) {
+    return this.http.request("GET", `luckperms/player/${encodeURIComponent(uuid)}/groups`);
+  }
+  /** Get a player's effective permission nodes. */
+  getPlayerPermissions(uuid) {
+    return this.http.request(
+      "GET",
+      `luckperms/player/${encodeURIComponent(uuid)}/permissions`
+    );
+  }
+  /** Add a permission node to a player. */
+  addPlayerPermission(uuid, permission, value = true) {
+    return this.http.request(
+      "POST",
+      `luckperms/player/${encodeURIComponent(uuid)}/permission`,
+      { body: { permission, value } }
+    );
+  }
+  /** Check whether a player has a given permission. */
+  checkPlayerPermission(uuid, permission) {
+    return this.http.request(
+      "POST",
+      `luckperms/player/${encodeURIComponent(uuid)}/check-permission`,
+      { body: { permission } }
+    );
+  }
+  /** Remove a permission node from a player. */
+  removePlayerPermission(uuid, permission) {
+    return this.http.request(
+      "DELETE",
+      `luckperms/player/${encodeURIComponent(uuid)}/permission`,
+      { body: { permission } }
+    );
+  }
+  /** Set a player's primary group. */
+  setPlayerGroup(uuid, group) {
+    return this.http.request(
+      "POST",
+      `luckperms/player/${encodeURIComponent(uuid)}/group`,
+      { body: { group } }
+    );
+  }
+  /** Remove a group from a player. */
+  removePlayerGroup(uuid, groupName) {
+    return this.http.request(
+      "DELETE",
+      `luckperms/player/${encodeURIComponent(uuid)}/group/${encodeURIComponent(groupName)}`
+    );
+  }
+  /** List all known groups. */
+  getGroups() {
+    return this.http.request("GET", "luckperms/groups");
+  }
+  /** Get the permissions attached to a specific group. */
+  getGroupPermissions(name) {
+    return this.http.request("GET", `luckperms/group/${encodeURIComponent(name)}/permissions`);
+  }
+};
+
+// src/modules/noxauth.ts
+var NoxAuthModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Get NoxAuth registration/auth info for a player by name. */
+  getPlayerAuth(name) {
+    return this.http.request("GET", `noxauth/player/${encodeURIComponent(name)}`);
+  }
+  /** Check whether a password matches a player's stored NoxAuth password. */
+  checkPassword(name, password) {
+    return this.http.request(
+      "POST",
+      `noxauth/player/${encodeURIComponent(name)}/check-password`,
+      { body: { password } }
+    );
+  }
+};
+
+// src/socket.ts
+function toWsUrl(baseUrl, route, apiKey) {
+  const url = new URL(`${baseUrl.replace(/\/+$/, "")}/${route.replace(/^\/+/, "")}`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (apiKey) url.searchParams.set("key", apiKey);
+  return url.toString();
+}
+var NoxAeApiSocket = class {
+  constructor(options) {
+    this.options = options;
+    const impl = options.webSocketImpl ?? globalThis.WebSocket;
+    if (!impl) {
+      throw new Error(
+        "No WebSocket implementation available in this runtime. Pass `webSocketImpl` in options."
+      );
+    }
+    this.wsImpl = impl;
+    this.open();
+  }
+  options;
+  socket = null;
+  listeners = /* @__PURE__ */ new Map();
+  reconnectAttempt = 0;
+  closedByUser = false;
+  wsImpl;
+  open() {
+    const url = toWsUrl(this.options.baseUrl, this.options.route ?? "events", this.options.apiKey);
+    const socket = new this.wsImpl(url);
+    socket.onopen = () => {
+      this.reconnectAttempt = 0;
+      this.emit("open", void 0);
+    };
+    socket.onmessage = (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      const parsed = safeParse(raw);
+      this.emit("message", parsed);
+      if (parsed && typeof parsed === "object" && "type" in parsed) {
+        const type = parsed.type;
+        if (type === "console" || type === "event") this.emit(type, parsed);
+      }
+    };
+    socket.onerror = (event) => {
+      this.emit("error", event);
+    };
+    socket.onclose = () => {
+      this.emit("close", void 0);
+      if (!this.closedByUser && this.options.autoReconnect !== false) {
+        this.scheduleReconnect();
+      }
+    };
+    this.socket = socket;
+  }
+  scheduleReconnect() {
+    const maxDelay = this.options.maxReconnectDelayMs ?? 3e4;
+    const delay = Math.min(maxDelay, 500 * 2 ** this.reconnectAttempt);
+    this.reconnectAttempt++;
+    setTimeout(() => {
+      if (!this.closedByUser) this.open();
+    }, delay);
+  }
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(listener);
+    return () => this.listeners.get(event)?.delete(listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    for (const listener of this.listeners.get(event) ?? []) listener(payload);
+  }
+  /** Send a raw payload over the socket, JSON-stringified if not already a string. */
+  send(payload) {
+    if (!this.socket || this.socket.readyState !== this.wsImpl.OPEN) {
+      throw new Error("Cannot send: socket is not open");
+    }
+    this.socket.send(typeof payload === "string" ? payload : JSON.stringify(payload));
+  }
+  /** Close the socket and stop reconnecting. */
+  close() {
+    this.closedByUser = true;
+    this.socket?.close();
+  }
+};
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/client.ts
+var NoxAeApiClient = class _NoxAeApiClient {
+  players;
+  economy;
+  server;
+  worlds;
+  plugins;
+  advancements;
+  placeholders;
+  /** Only works if LuckPerms is loaded on the target server. */
+  luckperms;
+  /** Only works if `noxauth.enabled: true` is set in the server config. */
+  noxauth;
+  http;
+  baseUrl;
+  apiKey;
+  constructor(options) {
+    this.http = new HttpEngine(options);
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.players = new PlayersModule(this.http);
+    this.economy = new EconomyModule(this.http);
+    this.server = new ServerModule(this.http);
+    this.worlds = new WorldsModule(this.http);
+    this.plugins = new PluginsModule(this.http);
+    this.advancements = new AdvancementsModule(this.http);
+    this.placeholders = new PlaceholdersModule(this.http);
+    this.luckperms = new LuckPermsModule(this.http);
+    this.noxauth = new NoxAuthModule(this.http);
+  }
+  /**
+   * Build a client from environment variables:
+   * `NOXAEAPI_BASE_URL` and `NOXAEAPI_KEY`.
+   *
+   * This is a convenience for Node-like runtimes; the SDK itself never
+   * reads `process.env` implicitly outside of this method, and does not
+   * load `.env` files — use a library like `dotenv` in your own app if
+   * you want that, then call `NoxAeApiClient.fromEnv()` after it's loaded.
+   */
+  static fromEnv(overrides = {}) {
+    const env = globalThis.process?.env;
+    const baseUrl = overrides.baseUrl ?? env?.NOXAEAPI_BASE_URL;
+    const apiKey = overrides.apiKey ?? env?.NOXAEAPI_KEY;
+    if (!baseUrl) {
+      throw new Error(
+        "NoxAeApiClient.fromEnv(): NOXAEAPI_BASE_URL is not set and no baseUrl override was given."
+      );
+    }
+    return new _NoxAeApiClient({ ...overrides, baseUrl, apiKey });
+  }
+  /** Open a WebSocket connection to the server (console tail or event stream). */
+  connect(options = {}) {
+    return new NoxAeApiSocket({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      ...options
+    });
+  }
+};
+
+export { NoxAeApiClient, NoxAeApiError, NoxAeApiForbiddenError, NoxAeApiNetworkError, NoxAeApiNotFoundError, NoxAeApiRateLimitError, NoxAeApiServerError, NoxAeApiSocket, NoxAeApiUnauthorizedError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map