@pelican.ts/sdk 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -0,0 +1,1017 @@
+// src/api/client/account.ts
+import z from "zod";
+var Account = class {
+  r;
+  constructor(requester) {
+    this.r = requester;
+  }
+  info = async () => {
+    const { data } = await this.r.get("/account");
+    return data.attributes;
+  };
+  updateEmail = async (newEmail, password) => {
+    newEmail = z.email().parse(newEmail);
+    await this.r.put("/account/email", { email: newEmail, password });
+  };
+  updatePassword = async (newPassword) => {
+    newPassword = z.string().min(8).parse(newPassword);
+    await this.r.put("/account/password", {
+      password: newPassword,
+      password_confirmation: newPassword
+    });
+  };
+  apiKeys = {
+    list: async () => {
+      const { data } = await this.r.get("/account/api-keys");
+      return data.data.map((k) => k.attributes);
+    },
+    create: async (description, allowed_ips) => {
+      allowed_ips = z.array(z.ipv4()).optional().parse(allowed_ips);
+      const { data } = await this.r.post("/account/api-keys", { description, allowed_ips });
+      return { ...data.attributes, secret_token: data.meta.secret_token };
+    },
+    delete: async (identifier) => {
+      await this.r.delete(`/account/api-keys/${identifier}`);
+    }
+  };
+  sshKeys = {
+    list: async () => {
+      const { data } = await this.r.get("/account/ssh-keys");
+      return data.data.map((k) => k.attributes);
+    },
+    create: async (name, public_key) => {
+      const { data } = await this.r.post("/account/ssh-keys", { name, public_key });
+      return data.attributes;
+    },
+    delete: async (fingerprint) => {
+      await this.r.post(`/account/ssh-keys/remove`, { fingerprint });
+    }
+  };
+  twoFactor = {
+    info: async () => {
+      const { data } = await this.r.get("/account/two-factor");
+      return data;
+    },
+    enable: async (code) => {
+      const { data } = await this.r.post("/account/two-factor", { code });
+      return data;
+    },
+    disable: async (password) => {
+      await this.r.delete("/account/two-factor", { data: { password } });
+    }
+  };
+};
+
+// src/api/client/client.ts
+import z5 from "zod";
+
+// src/api/client/server_databases.ts
+import z2 from "zod";
+var ServerDatabases = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async (include, page = 1) => {
+    z2.number().positive().parse(page);
+    const { data } = await this.r.get(`/servers/${this.id}/databases`, {
+      params: { include: include?.join(","), page }
+    });
+    return data.data.map((d) => d.attributes);
+  };
+  create = async (database, remote) => {
+    const { data } = await this.r.post(`/servers/${this.id}/databases`, { database, remote });
+    return data.attributes;
+  };
+  rotatePassword = async (database_id) => {
+    const { data } = await this.r.post(`/servers/${this.id}/databases/${database_id}/rotate-password`);
+    return data.attributes;
+  };
+  delete = async (database_id) => {
+    await this.r.delete(`/servers/${this.id}/databases/${database_id}`);
+  };
+};
+
+// src/api/client/server_files.ts
+import axios from "axios";
+var ServerFiles = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async (path) => {
+    const { data } = await this.r.get(`/servers/${this.id}/files/list`, {
+      params: { directory: path }
+    });
+    return data.data.map((r) => r.attributes);
+  };
+  /**
+   * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
+   */
+  contents = async (path) => {
+    const { data } = await this.r.get(`/servers/${this.id}/files/contents`, {
+      params: { file: path }
+    });
+    return data;
+  };
+  downloadGetUrl = async (path) => {
+    const { data } = await this.r.get(`/servers/${this.id}/files/download`, {
+      params: { file: path }
+    });
+    return data.attributes.url;
+  };
+  download = async (path) => {
+    const url = await this.downloadGetUrl(path);
+    const { data } = await axios.get(url, { responseType: "arraybuffer" });
+    return data;
+  };
+  rename = async (root = "/", files) => {
+    await this.r.put(`/servers/${this.id}/files/rename`, { root, files });
+  };
+  copy = async (location) => {
+    await this.r.post(`/servers/${this.id}/files/copy`, { location });
+  };
+  write = async (path, content) => {
+    await this.r.post(`/servers/${this.id}/files/write`, content, {
+      params: { file: path }
+    });
+  };
+  compress = async (root = "/", files, archive_name, extension) => {
+    await this.r.post(`/servers/${this.id}/files/compress`, { root, files, archive_name, extension });
+  };
+  decompress = async (root = "/", file) => {
+    await this.r.post(`/servers/${this.id}/files/decompress`, { root, file });
+  };
+  delete = async (root = "/", files) => {
+    await this.r.post(`/servers/${this.id}/files/delete`, { root, files });
+  };
+  createFolder = async (root = "/", name) => {
+    await this.r.post(`/servers/${this.id}/files/create-folder`, { root, name });
+  };
+  chmod = async (root = "/", files) => {
+    await this.r.post(`/servers/${this.id}/files/chmod`, { root, files });
+  };
+  pullFromRemote = async (url, directory, filename, use_header = false, foreground = false) => {
+    await this.r.post(`/servers/${this.id}/files/pull`, { url, directory, filename, use_header, foreground });
+  };
+  uploadGetUrl = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/files/upload`);
+    return data.attributes.url;
+  };
+  upload = async (file, root = "/") => {
+    const url = await this.uploadGetUrl();
+    await axios.post(url, { files: file }, {
+      headers: { "Content-Type": "multipart/form-data" },
+      params: { directory: root }
+    });
+  };
+};
+
+// src/api/client/server_schedules.ts
+var ServerSchedules = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/schedules`);
+    return data.data.map((d) => d.attributes);
+  };
+  create = async (params) => {
+    const { data } = await this.r.post(`/servers/${this.id}/schedules`, params);
+    return data.attributes;
+  };
+  control = (sched_id) => new ScheduleControl(this.r, this.id, sched_id);
+};
+var ScheduleControl = class {
+  r;
+  id;
+  sched_id;
+  constructor(requester, id, sched_id) {
+    this.r = requester;
+    this.id = id;
+    this.sched_id = sched_id;
+  }
+  info = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/schedules/${this.sched_id}`);
+    return data.attributes;
+  };
+  update = async (params) => {
+    const { data } = await this.r.post(`/servers/${this.id}/schedules/${this.sched_id}`, params);
+    return data.attributes;
+  };
+  delete = async () => {
+    await this.r.delete(`/servers/${this.id}/schedules/${this.sched_id}`);
+  };
+  execute = async () => {
+    await this.r.post(`/servers/${this.id}/schedules/${this.sched_id}/execute`);
+  };
+  tasks = {
+    create: async (opts) => {
+      const { data } = await this.r.post(`/servers/${this.id}/schedules/${this.sched_id}/tasks`, opts);
+      return data.attributes;
+    },
+    update: async (task_id, opts) => {
+      const { data } = await this.r.post(`/servers/${this.id}/schedules/${this.sched_id}/tasks/${task_id}`, opts);
+      return data.attributes;
+    },
+    delete: async (task_id) => {
+      await this.r.delete(`/servers/${this.id}/schedules/${this.sched_id}/tasks/${task_id}`);
+    }
+  };
+};
+
+// src/api/client/server_allocations.ts
+var ServerAllocations = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/network/allocations`);
+    return data.data.map((r) => r.attributes);
+  };
+  autoAssign = async () => {
+    const { data } = await this.r.post(`/servers/${this.id}/network/allocations`);
+    return data.attributes;
+  };
+  setNotes = async (alloc_id, notes) => {
+    const { data } = await this.r.post(`/servers/${this.id}/network/allocations/${alloc_id}`, { notes });
+    return data.attributes;
+  };
+  setPrimary = async (alloc_id) => {
+    const { data } = await this.r.post(`/servers/${this.id}/network/allocations/${alloc_id}/primary`);
+    return data.attributes;
+  };
+  unassign = async (alloc_id) => {
+    await this.r.delete(`/servers/${this.id}/network/allocations/${alloc_id}`);
+  };
+};
+
+// src/api/client/server_users.ts
+var ServerUsers = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/users`);
+    return data.data.map((d) => d.attributes);
+  };
+  create = async (email, permissions) => {
+    const { data } = await this.r.post(`/servers/${this.id}/users`, { email, permissions });
+    return data.attributes;
+  };
+  info = async (user_id) => {
+    const { data } = await this.r.get(`/servers/${this.id}/users/${user_id}`);
+    return data.attributes;
+  };
+  update = async (user_id, permissions) => {
+    const { data } = await this.r.put(`/servers/${this.id}/users/${user_id}`, { permissions });
+    return data.attributes;
+  };
+  delete = async (user_id) => {
+    await this.r.delete(`/servers/${this.id}/users/${user_id}`);
+  };
+};
+
+// src/api/client/server_backups.ts
+import axios2 from "axios";
+import z3 from "zod";
+var ServerBackups = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async (page = 1) => {
+    z3.number().positive().parse(page);
+    const { data } = await this.r.get(`/servers/${this.id}/backups`, {
+      params: { page }
+    });
+    return data.data.map((d) => d.attributes);
+  };
+  create = async (args) => {
+    args.name = z3.string().max(255).optional().parse(args.name);
+    const { data } = await this.r.post(`/servers/${this.id}/backups`, {
+      name: args.name,
+      is_locked: args.is_locked,
+      ignored_files: args.ignored_files.join("\n")
+    });
+    return data.attributes;
+  };
+  info = async (backup_uuid) => {
+    const { data } = await this.r.get(`/servers/${this.id}/backups/${backup_uuid}`);
+    return data.attributes;
+  };
+  downloadGetUrl = async (backup_uuid) => {
+    const { data } = await this.r.get(`/servers/${this.id}/backups/${backup_uuid}/download`);
+    return data.attributes.url;
+  };
+  download = async (backup_uuid) => {
+    const url = await this.downloadGetUrl(backup_uuid);
+    const { data } = await axios2.get(url, { responseType: "arraybuffer" });
+    return data;
+  };
+  delete = async (backup_uuid) => {
+    await this.r.delete(`/servers/${this.id}/backups/${backup_uuid}`);
+  };
+};
+
+// src/api/client/server_startup.ts
+var ServerStartup = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/startup`);
+    return {
+      object: "list",
+      meta: data.meta,
+      data: data.data.map((d) => d.attributes)
+    };
+  };
+  set = async (key, value) => {
+    const { data } = await this.r.put(`/servers/${this.id}/startup/variable`, { key, value });
+    return data.attributes;
+  };
+};
+
+// src/api/client/server_settings.ts
+import z4 from "zod";
+var ServerSettings = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  rename = async (name) => {
+    name = z4.string().max(255).parse(name);
+    await this.r.post(`/servers/${this.id}/settings/rename`, { name });
+  };
+  updateDescription = async (description) => {
+    await this.r.post(`/servers/${this.id}/settings/description`, { description });
+  };
+  reinstall = async () => {
+    await this.r.post(`/servers/${this.id}/settings/reinstall`);
+  };
+  changeDockerImage = async (image) => {
+    await this.r.post(`/servers/${this.id}/settings/docker-image`, { image });
+  };
+};
+
+// src/api/client/server_websocket.ts
+import { EventEmitter } from "events";
+import WebSocket from "isomorphic-ws";
+import stripColor from "strip-color";
+var isBrowser = typeof window !== "undefined";
+var RECONNECT_ERRORS = /* @__PURE__ */ new Set([
+  "jwt: exp claim is invalid",
+  "jwt: created too far in past (denylist)"
+]);
+var FALLBACK_LOG_MESSAGE = "No logs - is the server online?";
+var ServerWebsocket = class {
+  r;
+  serverId;
+  socket;
+  currentToken;
+  bus = new EventEmitter();
+  debugLogging = false;
+  stripColors;
+  detachMessageListener;
+  constructor(requester, id, stripColors = false) {
+    this.r = requester;
+    this.serverId = id;
+    this.stripColors = stripColors;
+  }
+  on(event, listener) {
+    const handler = listener;
+    this.bus.on(event, handler);
+    return () => {
+      this.bus.removeListener(event, handler);
+    };
+  }
+  deregister(event, listener) {
+    const handler = listener;
+    this.bus.removeListener(event, handler);
+  }
+  emit(event, ...args) {
+    if (args.length === 0) {
+      this.bus.emit(event);
+    } else {
+      this.bus.emit(event, args[0]);
+    }
+  }
+  async connect(resumable, debugLogging) {
+    this.debugLogging = debugLogging ?? false;
+    if (this.socket) {
+      return;
+    }
+    const socketUrl = await this.refreshCredentials();
+    this.socket = isBrowser ? new WebSocket(socketUrl) : new WebSocket(socketUrl, void 0, { origin: new URL(socketUrl).origin });
+    await new Promise((resolve, reject) => {
+      const socket = this.socket;
+      if (!socket) {
+        reject(new Error("Failed to create socket connection"));
+        return;
+      }
+      socket.onopen = async () => {
+        try {
+          await this.authenticate();
+          this.attachMessageListener();
+          socket.onopen = null;
+          socket.onerror = null;
+          resolve();
+        } catch (error) {
+          socket.onopen = null;
+          socket.onerror = null;
+          reject(error instanceof Error ? error : new Error("Websocket authentication failed"));
+        }
+      };
+      socket.onerror = (event) => {
+        socket.onopen = null;
+        socket.onerror = null;
+        reject(event instanceof Error ? event : new Error("Websocket connection error"));
+      };
+    });
+    if (resumable) {
+      this.makeResumable(true);
+    }
+  }
+  onSocketDisconnect(handler) {
+    if (!this.socket) {
+      console.error(new Error("No socket connection"));
+      return;
+    }
+    this.socket.onclose = handler;
+  }
+  onSocketError(handler) {
+    if (!this.socket) {
+      console.error(new Error("No socket connection"));
+      return;
+    }
+    this.socket.onerror = handler;
+  }
+  makeResumable(disconnectsToo) {
+    const scheduleReconnect = () => {
+      setTimeout(() => {
+        const previous = this.socket;
+        this.detachMessageListener?.();
+        this.detachMessageListener = void 0;
+        this.socket = void 0;
+        previous?.close();
+        void this.connect(true, this.debugLogging);
+      }, 1e3);
+    };
+    this.onSocketError(() => scheduleReconnect());
+    if (disconnectsToo) {
+      this.onSocketDisconnect(() => scheduleReconnect());
+    }
+  }
+  attachMessageListener() {
+    if (!this.socket) {
+      throw new Error("No socket connection");
+    }
+    this.detachMessageListener?.();
+    const handler = (event) => {
+      void this.handleIncomingMessage(event);
+    };
+    if (typeof this.socket.addEventListener === "function") {
+      this.socket.addEventListener("message", handler);
+      this.detachMessageListener = () => {
+        this.socket?.removeEventListener?.("message", handler);
+      };
+    } else {
+      const fallback = (data) => handler({ data });
+      const socket = this.socket;
+      socket.on?.("message", fallback);
+      this.detachMessageListener = () => {
+        const target = this.socket;
+        if (!target) {
+          return;
+        }
+        if (typeof target.off === "function") {
+          target.off("message", fallback);
+        } else if (typeof target.removeListener === "function") {
+          target.removeListener("message", fallback);
+        }
+      };
+    }
+  }
+  async handleIncomingMessage(event) {
+    const message = this.parseMessage(event);
+    if (!message) {
+      return;
+    }
+    try {
+      await this.dispatchMessage(message);
+    } catch (error) {
+      if (this.debugLogging) {
+        console.error("Error while handling websocket message", error);
+      }
+    }
+  }
+  parseMessage(event) {
+    const payload = this.normalisePayload(event);
+    if (!payload) {
+      return null;
+    }
+    try {
+      return JSON.parse(payload);
+    } catch (error) {
+      if (this.debugLogging) {
+        console.warn("Failed to parse websocket payload", error);
+      }
+      return null;
+    }
+  }
+  normalisePayload(event) {
+    if (typeof event === "string") {
+      return event;
+    }
+    if (typeof event === "object" && event !== null && "data" in event) {
+      return this.normalisePayload(event.data);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(event)) {
+      return event.toString("utf8");
+    }
+    if (typeof ArrayBuffer !== "undefined" && event instanceof ArrayBuffer) {
+      if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder().decode(new Uint8Array(event));
+      }
+      if (typeof Buffer !== "undefined") {
+        return Buffer.from(event).toString("utf8");
+      }
+    }
+    return null;
+  }
+  async dispatchMessage(message) {
+    switch (message.event) {
+      case "auth success" /* AUTH_SUCCESS */: {
+        if (this.debugLogging) {
+          console.debug("Auth success");
+        }
+        this.emit("auth success" /* AUTH_SUCCESS */);
+        break;
+      }
+      case "status" /* STATUS */: {
+        if (this.debugLogging) {
+          console.debug("Received status event", message.args[0]);
+        }
+        this.emit("status" /* STATUS */, message.args[0]);
+        break;
+      }
+      case "console output" /* CONSOLE_OUTPUT */: {
+        let output = message.args[0];
+        if (this.stripColors) {
+          output = stripColor(output);
+        }
+        if (this.debugLogging) {
+          console.debug("Received console output", output);
+        }
+        this.emit("console output" /* CONSOLE_OUTPUT */, output);
+        break;
+      }
+      case "stats" /* STATS */: {
+        try {
+          const payload = JSON.parse(message.args[0]);
+          this.emit("stats" /* STATS */, payload);
+        } catch (error) {
+          if (this.debugLogging) {
+            console.warn("Failed to parse stats payload", error);
+          }
+        }
+        break;
+      }
+      case "daemon error" /* DAEMON_ERROR */: {
+        this.emit("daemon error" /* DAEMON_ERROR */);
+        break;
+      }
+      case "backup completed" /* BACKUP_COMPLETED */: {
+        try {
+          const payload = JSON.parse(message.args[0]);
+          this.emit("backup completed" /* BACKUP_COMPLETED */, payload);
+        } catch (error) {
+          if (this.debugLogging) {
+            console.warn("Failed to parse backup payload", error);
+          }
+        }
+        break;
+      }
+      case "daemon message" /* DAEMON_MESSAGE */: {
+        let output = message.args[0];
+        if (this.stripColors) {
+          output = stripColor(output);
+        }
+        this.emit("daemon message" /* DAEMON_MESSAGE */, output);
+        break;
+      }
+      case "install output" /* INSTALL_OUTPUT */: {
+        let output = message.args[0];
+        if (this.stripColors) {
+          output = stripColor(output);
+        }
+        this.emit("install output" /* INSTALL_OUTPUT */, output);
+        break;
+      }
+      case "backup restore completed" /* BACKUP_RESTORE_COMPLETED */: {
+        this.emit("backup restore completed" /* BACKUP_RESTORE_COMPLETED */);
+        break;
+      }
+      case "install completed" /* INSTALL_COMPLETED */: {
+        this.emit("install completed" /* INSTALL_COMPLETED */);
+        break;
+      }
+      case "install started" /* INSTALL_STARTED */: {
+        this.emit("install started" /* INSTALL_STARTED */);
+        break;
+      }
+      case "transfer logs" /* TRANSFER_LOGS */: {
+        this.emit("transfer logs" /* TRANSFER_LOGS */, message.args[0]);
+        break;
+      }
+      case "transfer status" /* TRANSFER_STATUS */: {
+        this.emit("transfer status" /* TRANSFER_STATUS */, message.args[0]);
+        break;
+      }
+      case "token expiring" /* TOKEN_EXPIRING */: {
+        this.emit("token expiring" /* TOKEN_EXPIRING */);
+        if (this.debugLogging) {
+          console.warn("Token expiring, renewing...");
+        }
+        await this.refreshCredentials();
+        await this.authenticate();
+        break;
+      }
+      case "token expired" /* TOKEN_EXPIRED */: {
+        this.emit("token expired" /* TOKEN_EXPIRED */);
+        throw new Error("Token expired");
+      }
+      case "jwt error" /* JWT_ERROR */: {
+        const reason = message.args[0];
+        if (RECONNECT_ERRORS.has(reason)) {
+          this.emit("token expiring" /* TOKEN_EXPIRING */);
+          if (this.debugLogging) {
+            console.warn("Token expiring (JWT error), renewing...");
+          }
+          await this.refreshCredentials();
+          await this.authenticate();
+        } else {
+          this.emit("jwt error" /* JWT_ERROR */, reason);
+          throw new Error("Token expired");
+        }
+        break;
+      }
+      default: {
+        if (this.debugLogging) {
+          console.warn("Unknown websocket event", message);
+        }
+        break;
+      }
+    }
+  }
+  async refreshCredentials() {
+    const { data } = await this.r.get(`/servers/${this.serverId}/websocket`);
+    this.currentToken = data.data.token;
+    return data.data.socket;
+  }
+  async authenticate() {
+    if (!this.socket) {
+      throw new Error("No socket connection");
+    }
+    if (!this.currentToken) {
+      throw new Error("Missing websocket token");
+    }
+    this.socket.send(JSON.stringify({ event: "auth", args: [this.currentToken] }));
+  }
+  disconnect() {
+    this.detachMessageListener?.();
+    this.detachMessageListener = void 0;
+    if (this.socket) {
+      this.socket.close();
+      this.socket = void 0;
+    }
+  }
+  requestStats() {
+    this.send("send stats", [null]);
+  }
+  requestLogs() {
+    this.send("send logs", [null]);
+  }
+  send(event, args) {
+    if (!this.socket) {
+      if (this.debugLogging) {
+        console.warn(`Attempted to send "${event}" without an active websocket connection`);
+      }
+      return;
+    }
+    this.socket.send(JSON.stringify({ event, args }));
+  }
+  getStats() {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("No socket connection"));
+        return;
+      }
+      let off;
+      const timeout = setTimeout(() => {
+        off?.();
+        reject(new Error("Timed out waiting for stats"));
+      }, 5e3);
+      off = this.on("stats" /* STATS */, (payload) => {
+        clearTimeout(timeout);
+        off?.();
+        resolve(payload);
+      });
+      this.requestStats();
+    });
+  }
+  getLogs() {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("No socket connection"));
+        return;
+      }
+      const lines = [];
+      let off;
+      let initialTimeout;
+      let idleTimeout;
+      const finalize = (payload) => {
+        off?.();
+        if (initialTimeout) {
+          clearTimeout(initialTimeout);
+        }
+        if (idleTimeout) {
+          clearTimeout(idleTimeout);
+        }
+        resolve(payload);
+      };
+      initialTimeout = setTimeout(() => {
+        finalize(lines.length > 0 ? lines : [FALLBACK_LOG_MESSAGE]);
+      }, 5e3);
+      off = this.on("console output" /* CONSOLE_OUTPUT */, (line) => {
+        lines.push(line);
+        if (initialTimeout) {
+          clearTimeout(initialTimeout);
+          initialTimeout = void 0;
+        }
+        if (idleTimeout) {
+          clearTimeout(idleTimeout);
+        }
+        idleTimeout = setTimeout(() => {
+          finalize(lines);
+        }, 1e3);
+      });
+      this.requestLogs();
+    });
+  }
+  sendPoweraction(action) {
+    this.send("set state", [action]);
+  }
+  sendCommand(cmd) {
+    this.send("send command", [cmd]);
+  }
+};
+
+// src/api/client/server_activity.ts
+var ServerActivity = class {
+  r;
+  id;
+  constructor(r, id) {
+    this.r = r;
+    this.id = id;
+  }
+  list = async (page = 1, per_page = 25) => {
+    const { data } = await this.r.get(`/server/${this.id}/activity`, {
+      params: {
+        page,
+        per_page
+      }
+    });
+    return data.data.map((log) => log.attributes);
+  };
+};
+
+// src/api/client/server.ts
+var ServerClient = class {
+  r;
+  id;
+  activity;
+  databases;
+  files;
+  schedules;
+  allocations;
+  users;
+  backups;
+  startup;
+  variables;
+  settings;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+    this.activity = new ServerActivity(requester, id);
+    this.databases = new ServerDatabases(requester, id);
+    this.files = new ServerFiles(requester, id);
+    this.schedules = new ServerSchedules(requester, id);
+    this.allocations = new ServerAllocations(requester, id);
+    this.users = new ServerUsers(requester, id);
+    this.backups = new ServerBackups(requester, id);
+    this.startup = new ServerStartup(requester, id);
+    this.variables = this.startup;
+    this.settings = new ServerSettings(requester, id);
+  }
+  info = async (include) => {
+    const { data } = await this.r.get(`/servers/${this.id}`, {
+      params: { include: include?.join(",") }
+    });
+    return data.attributes;
+  };
+  websocket = (stripColors = false) => {
+    return new ServerWebsocket(this.r, this.id, stripColors);
+  };
+  resources = async () => {
+    const { data } = await this.r.get(`/servers/${this.id}/resources`);
+    return data.attributes;
+  };
+  command = async (command) => {
+    await this.r.post(`/servers/${this.id}/command`, { command });
+  };
+  power = async (signal) => {
+    await this.r.post(`/servers/${this.id}/power`, { signal });
+  };
+};
+
+// src/api/client/client.ts
+var Client = class {
+  account;
+  r;
+  constructor(requester) {
+    this.r = requester;
+    this.account = new Account(requester);
+  }
+  listPermissions = async () => {
+    const { data } = await this.r.get("/permissions");
+    return data.attributes.permissions;
+  };
+  listServers = async (type = "accessible", page = 1, per_page = 50, include) => {
+    z5.number().positive().parse(page);
+    const { data } = await this.r.get("/servers", {
+      params: { type, page, include: include?.join(",") }
+    });
+    return data.data.map((s) => s.attributes);
+  };
+  server = (uuid) => new ServerClient(this.r, uuid);
+};
+
+// src/api/application/users.ts
+import z6 from "zod";
+
+// src/utils/transform.ts
+var ArrayQueryParams = (p) => {
+  const params = new URLSearchParams();
+  const o = {};
+  for (const [param, value] of Object.entries(p)) {
+    for (const [key, val] of Object.entries(value)) {
+      o[`${param}[${key}]`] = val;
+    }
+  }
+  return o;
+};
+var SortParam = (key, p) => {
+  return `${p === "desc" ? "-" : ""}${key}`;
+};
+
+// src/api/application/users.ts
+var Users = class {
+  r;
+  constructor(requester) {
+    this.r = requester;
+  }
+  list = async ({ ...opts }, page = 1) => {
+    z6.number().positive().parse(page);
+    const { data } = await this.r.get("/users", {
+      params: {
+        include: opts.include?.join(","),
+        page,
+        ...ArrayQueryParams({ filters: opts.filters || {} }),
+        sort: opts.sort?.id ? SortParam("id", opts.sort?.id) : SortParam("uuid", opts.sort?.uuid)
+      }
+    });
+    return data.data.map((d) => d.attributes);
+  };
+  info = async (id, { include }) => {
+    z6.number().positive().parse(id);
+    const { data } = await this.r.get(`/users/${id}`, {
+      params: { include: include?.join(",") }
+    });
+    return data.attributes;
+  };
+  infoByExternal = async (external_id, { include }) => {
+    const { data } = await this.r.get(`/users/external/${external_id}`);
+    return data.attributes;
+  };
+  create = async (user) => {
+    const { data } = await this.r.post("/users", user);
+    return data.attributes;
+  };
+  update = async (id, user) => {
+    z6.number().positive().parse(id);
+    const { data } = await this.r.put(`/users/${id}`, user);
+    return data.attributes;
+  };
+  delete = async (id) => {
+    z6.number().positive().parse(id);
+    await this.r.delete(`/users/${id}`);
+  };
+};
+
+// src/api/application/client.ts
+var Client2 = class {
+  r;
+  users;
+  constructor(requester) {
+    this.r = requester;
+    this.users = new Users(requester);
+  }
+};
+
+// src/api/base/request.ts
+import z7 from "zod";
+import axios3 from "axios";
+
+// src/api/base/types.ts
+var PterodactylException = class extends Error {
+  data;
+  status;
+  constructor(message, data, status) {
+    super(message);
+    this.data = data;
+    this.status = status;
+  }
+};
+
+// src/api/base/request.ts
+var Agent = class {
+  base_url;
+  token;
+  requester;
+  constructor(url, token, type) {
+    this.base_url = z7.url("Invalid URL Schema").parse(url);
+    this.token = z7.string().regex(/^(ptl[ac]|pacc|papp)_.+$/, "Invalid token type").parse(token);
+    this.requester = axios3.create({
+      baseURL: this.base_url.replace(/\/+$/, "") + `/api/${type}`,
+      timeout: 3e3,
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+    this.requester.interceptors.response.use(void 0, (error) => {
+      if (error.response && error.response.status === 400) {
+        return Promise.reject(new PterodactylException(
+          "Invalid request data",
+          error.response.data,
+          error.response.status
+        ));
+      }
+      return Promise.reject(error);
+    });
+  }
+};
+
+// src/index.ts
+var PelicanClient = class extends Client {
+  constructor(url, token) {
+    const ax = new Agent(url, token, "client");
+    super(ax.requester);
+  }
+};
+var PelicanApplication = class extends Client2 {
+  constructor(url, token) {
+    const ax = new Agent(url, token, "application");
+    super(ax.requester);
+  }
+};
+export {
+  PelicanApplication,
+  PelicanClient
+};
+/*
+ * @author BothimTV
+ * @license MIT
+ */
+//# sourceMappingURL=index.mjs.map