@pelican.ts/sdk 0.4.14 → 0.4.16-next.0

package/dist/api/index.js

@@ -35,1099 +35,584 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/api/client/account.ts
+// src/api/application/database_hosts.ts
 var import_zod = __toESM(require("zod"));
-var Account = class {
+var DatabaseHosts = class {
   r;
-  constructor(requester) {
-    this.r = requester;
+  constructor(r) {
+    this.r = r;
   }
-  info = async () => {
-    const { data } = await this.r.get("/account");
-    return data.attributes;
+  list = async (page = 1) => {
+    const { data } = await this.r.get("/database-hosts", { params: { page } });
+    return data.data.map((d) => d.attributes);
   };
-  updateEmail = async (newEmail, password) => {
-    newEmail = import_zod.default.email().parse(newEmail);
-    await this.r.put("/account/email", { email: newEmail, password });
+  info = async (id) => {
+    const { data } = await this.r.get(`/database-hosts/${id}`);
+    return data.attributes;
   };
-  updatePassword = async (newPassword) => {
-    newPassword = import_zod.default.string().min(8).parse(newPassword);
-    await this.r.put("/account/password", {
-      password: newPassword,
-      password_confirmation: newPassword
+  // TODO: find out why API returns 500
+  create = async (opts) => {
+    opts = CreateDBHostSchema.parse(opts);
+    await this.r.post(
+      "/database-hosts",
+      opts
+    ).catch((e) => {
     });
   };
-  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 = import_zod.default.array(import_zod.default.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}`);
-    }
+  update = async (id, opts) => {
+    opts = CreateDBHostSchema.parse(opts);
+    const { data } = await this.r.patch(`/database-hosts/${id}`, opts);
+    return data.attributes;
   };
-  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.delete(`/account/ssh-keys/${fingerprint}`);
-    }
+  delete = async (id) => {
+    await this.r.delete(`/database-hosts/${id}`);
   };
 };
+var CreateDBHostSchema = import_zod.default.object({
+  name: import_zod.default.string().min(1).max(255),
+  host: import_zod.default.string(),
+  port: import_zod.default.number().min(1).max(65535),
+  username: import_zod.default.string().min(1).max(255),
+  password: import_zod.default.string().optional(),
+  node_ids: import_zod.default.array(import_zod.default.string()).optional(),
+  max_databases: import_zod.default.number().optional()
+});
 
-// src/api/client/client.ts
-var import_zod5 = __toESM(require("zod"));
-
-// src/api/client/server_databases.ts
-var import_zod2 = __toESM(require("zod"));
-var ServerDatabases = class {
+// src/api/application/eggs.ts
+var Eggs = class {
   r;
-  id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
+  constructor(r) {
+    this.r = r;
   }
-  list = async (include, page = 1) => {
-    import_zod2.default.number().positive().parse(page);
-    const { data } = await this.r.get(`/servers/${this.id}/databases`, {
-      params: { include: include?.join(","), page }
-    });
+  list = async () => {
+    const { data } = await this.r.get(
+      "/eggs"
+    );
     return data.data.map((d) => d.attributes);
   };
-  create = async (database, remote) => {
-    const { data } = await this.r.post(`/servers/${this.id}/databases`, { database, remote });
+  info = async (id) => {
+    const { data } = await this.r.get(
+      `/eggs/${id}`
+    );
     return data.attributes;
   };
-  rotatePassword = async (database_id) => {
-    const { data } = await this.r.post(`/servers/${this.id}/databases/${database_id}/rotate-password`);
-    return data.attributes;
+  export = async (id, format) => {
+    const { data } = await this.r.get(`/eggs/${id}/export`, {
+      params: { format },
+      transformResponse: (r) => r
+    });
+    return data;
   };
-  delete = async (database_id) => {
-    await this.r.delete(`/servers/${this.id}/databases/${database_id}`);
+  infoExportable = async (id) => {
+    const { data } = await this.r.get(`/eggs/${id}/export`, {
+      params: { format: "json" }
+    });
+    return data;
   };
 };
 
-// src/api/client/server_files.ts
-var import_axios = __toESM(require("axios"));
-var ServerFiles = class {
+// src/api/application/mounts.ts
+var import_zod2 = __toESM(require("zod"));
+var Mounts = class {
   r;
-  id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
+  constructor(r) {
+    this.r = r;
   }
-  list = async (path) => {
-    const { data } = await this.r.get(`/servers/${this.id}/files/list`, { params: { directory: path } });
-    return data.data.map((r) => r.attributes);
+  list = async () => {
+    const { data } = await this.r.get("/mounts");
+    return data.data.map((d) => d.attributes);
   };
-  /**
-   * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
-   */
-  contents = async (path) => {
+  info = async (id) => {
     const { data } = await this.r.get(
-      `/servers/${this.id}/files/contents`,
-      { params: { file: path } }
+      `/mounts/${id}`
     );
-    return data;
-  };
-  downloadGetUrl = async (path) => {
-    const { data } = await this.r.get(`/servers/${this.id}/files/download`, { params: { file: path } });
-    return data.attributes.url;
+    return data.attributes;
   };
-  download = async (path) => {
-    const url = await this.downloadGetUrl(path);
-    const { data } = await import_axios.default.get(url, {
-      responseType: "arraybuffer"
-    });
-    return data;
+  create = async (opts) => {
+    opts = CreateMountSchema.parse(opts);
+    const { data } = await this.r.post(
+      "/mounts",
+      opts
+    );
+    return data.attributes;
   };
-  rename = async (root = "/", files) => {
-    await this.r.put(`/servers/${this.id}/files/rename`, { root, files });
+  update = async (id, opts) => {
+    opts = CreateMountSchema.parse(opts);
+    const { data } = await this.r.patch(
+      `/mounts/${id}`,
+      opts
+    );
+    return data.attributes;
   };
-  copy = async (location) => {
-    await this.r.post(`/servers/${this.id}/files/copy`, { location });
+  delete = async (id) => {
+    await this.r.delete(`/mounts/${id}`);
   };
-  write = async (path, content) => {
-    await this.r.post(`/servers/${this.id}/files/write`, content, {
-      params: { file: path }
-    });
+  listAssignedEggs = async (id) => {
+    const { data } = await this.r.get(`/mounts/${id}/eggs`);
+    return data.data.map((d) => d.attributes);
   };
-  compress = async (root = "/", files, archive_name, extension) => {
-    const { data } = await this.r.post(`/servers/${this.id}/files/compress`, {
-      root,
-      files,
-      archive_name,
-      extension
-    });
-    return data.attributes;
+  assignEggs = async (id, eggs) => {
+    await this.r.post(`/mounts/${id}/eggs`, { eggs });
   };
-  decompress = async (root = "/", file) => {
-    await this.r.post(`/servers/${this.id}/files/decompress`, { root, file });
+  unassignEgg = async (id, egg_id) => {
+    await this.r.delete(`/mounts/${id}/eggs/${egg_id}`);
   };
-  delete = async (root = "/", files) => {
-    await this.r.post(`/servers/${this.id}/files/delete`, { root, files });
+  listAssignedNodes = async (id) => {
+    const { data } = await this.r.get(`/mounts/${id}/nodes`);
+    return data.data.map((d) => d.attributes);
   };
-  createFolder = async (root = "/", name) => {
-    await this.r.post(`/servers/${this.id}/files/create-folder`, {
-      root,
-      name
-    });
+  assignNodes = async (id, nodes) => {
+    await this.r.post(`/mounts/${id}/nodes`, { nodes });
   };
-  chmod = async (root = "/", files) => {
-    await this.r.post(`/servers/${this.id}/files/chmod`, { root, files });
+  unassignNode = async (id, node_id) => {
+    await this.r.delete(`/mounts/${id}/nodes/${node_id}`);
   };
-  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
-    });
+  listAssignedServers = async (id) => {
+    const { data } = await this.r.get(`/mounts/${id}/servers`);
+    return data.data.map((d) => d.attributes);
   };
-  uploadGetUrl = async () => {
-    const { data } = await this.r.get(`/servers/${this.id}/files/upload`);
-    return data.attributes.url;
+  assignServers = async (id, servers) => {
+    await this.r.post(`/mounts/${id}/servers`, { servers });
   };
-  upload = async (file, root = "/") => {
-    const url = await this.uploadGetUrl();
-    await import_axios.default.post(
-      url,
-      { files: file },
-      {
-        headers: { "Content-Type": "multipart/form-data" },
-        params: { directory: root }
-      }
-    );
+  unassignServer = async (id, server_id) => {
+    await this.r.delete(`/mounts/${id}/servers/${server_id}`);
   };
 };
+var CreateMountSchema = import_zod2.default.object({
+  name: import_zod2.default.string().min(1).max(255),
+  description: import_zod2.default.string().optional(),
+  source: import_zod2.default.string(),
+  target: import_zod2.default.string(),
+  read_only: import_zod2.default.boolean().optional()
+});
 
-// src/api/client/server_schedules.ts
-var ServerSchedules = class {
+// src/api/application/nodes.ts
+var import_zod4 = __toESM(require("zod"));
+
+// src/api/application/nodes_allocations.ts
+var import_zod3 = __toESM(require("zod"));
+var NodesAllocations = class {
   r;
   id;
   constructor(requester, id) {
     this.r = requester;
     this.id = id;
   }
-  list = async () => {
-    const { data } = await this.r.get(`/servers/${this.id}/schedules`);
+  list = async (include) => {
+    const { data } = await this.r.get(`/nodes/${this.id}/allocations`, {
+      params: { include: include?.join(",") }
+    });
     return data.data.map((d) => d.attributes);
   };
-  create = async (params) => {
-    const { data } = await this.r.post(`/servers/${this.id}/schedules`, params);
-    return data.attributes;
+  create = async (ip, ports, alias) => {
+    import_zod3.default.ipv4().parse(ip);
+    import_zod3.default.ipv4().or(import_zod3.default.url().max(255)).optional().parse(alias);
+    import_zod3.default.array(import_zod3.default.number()).or(import_zod3.default.string().regex(/\d+-\d+/)).parse(ports);
+    await this.r.post(`/nodes/${this.id}/allocations`, { ip, ports, alias });
+  };
+  delete = async (alloc_id) => {
+    await this.r.delete(`/nodes/${this.id}/allocations/${alloc_id}`);
   };
-  control = (sched_id) => new ScheduleControl(this.r, this.id, sched_id);
 };
-var ScheduleControl = class {
+
+// src/api/application/nodes.ts
+var Nodes = class {
   r;
-  id;
-  sched_id;
-  constructor(requester, id, sched_id) {
+  constructor(requester) {
     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}`);
+  list = async (include, page = 1) => {
+    import_zod4.default.number().positive().parse(page);
+    const { data } = await this.r.get("/nodes", { params: { include: include?.join(","), page } });
+    return data.data.map((s) => s.attributes);
+  };
+  listDeployable = async (filters, include, page = 1) => {
+    import_zod4.default.number().positive().parse(page);
+    const { data } = await this.r.get("/nodes/deployable", {
+      params: {
+        include: include?.join(","),
+        disk: filters.disk,
+        memory: filters.memory,
+        cpu: filters.cpu,
+        location_ids: filters.location_ids,
+        tags: filters.tags,
+        page
+      }
+    });
+    return data.data.map((s) => s.attributes);
+  };
+  info = async (id, include) => {
+    import_zod4.default.number().positive().parse(id);
+    const { data } = await this.r.get(
+      `/nodes/${id}`,
+      { params: { include: include?.join(",") } }
+    );
     return data.attributes;
   };
-  update = async (params) => {
-    const { data } = await this.r.post(`/servers/${this.id}/schedules/${this.sched_id}`, params);
+  create = async (node) => {
+    node = NodeCreateSchema.parse(node);
+    const { data } = await this.r.post(
+      "/nodes",
+      node
+    );
     return data.attributes;
   };
-  delete = async () => {
-    await this.r.delete(`/servers/${this.id}/schedules/${this.sched_id}`);
+  get_configuration = async (id) => {
+    import_zod4.default.number().positive().parse(id);
+    const { data } = await this.r.get(
+      `/nodes/${id}/configuration`
+    );
+    return data;
   };
-  execute = async () => {
-    await this.r.post(
-      `/servers/${this.id}/schedules/${this.sched_id}/execute`
+  update = async (id, node) => {
+    import_zod4.default.number().positive().parse(id);
+    node = NodeCreateSchema.parse(node);
+    const { data } = await this.r.patch(
+      `/nodes/${id}`,
+      node
     );
+    return data.attributes;
   };
-  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}`
-      );
-    }
+  delete = async (id) => {
+    import_zod4.default.number().positive().parse(id);
+    await this.r.delete(`/nodes/${id}`);
   };
+  allocations = (server_id) => new NodesAllocations(this.r, server_id);
 };
+var NodeCreateSchema = import_zod4.default.object({
+  name: import_zod4.default.string().min(1).max(100),
+  description: import_zod4.default.string().optional(),
+  public: import_zod4.default.boolean().optional(),
+  fqdn: import_zod4.default.string().nonempty(),
+  scheme: import_zod4.default.enum(["http", "https"]),
+  behind_proxy: import_zod4.default.boolean().optional(),
+  memory: import_zod4.default.number().min(0),
+  memory_overallocate: import_zod4.default.number().min(-1),
+  disk: import_zod4.default.number().min(0),
+  disk_overallocate: import_zod4.default.number().min(-1),
+  cpu: import_zod4.default.number().min(0),
+  cpu_overallocate: import_zod4.default.number().min(-1),
+  daemon_base: import_zod4.default.string().nonempty().optional(),
+  daemon_sftp: import_zod4.default.number().min(1).max(65535),
+  daemon_sftp_alias: import_zod4.default.string().optional(),
+  daemon_listen: import_zod4.default.number().min(1).max(65535),
+  daemon_connect: import_zod4.default.number().min(1).max(65535),
+  maintenance_mode: import_zod4.default.boolean().optional(),
+  upload_size: import_zod4.default.number().min(1).max(1024),
+  tags: import_zod4.default.array(import_zod4.default.string()).optional()
+});
 
-// src/api/client/server_allocations.ts
-var ServerAllocations = class {
+// src/api/application/roles.ts
+var Roles = class {
   r;
-  id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
+  constructor(r) {
+    this.r = r;
   }
-  list = async () => {
-    const { data } = await this.r.get(`/servers/${this.id}/network/allocations`);
+  list = async (page = 1) => {
+    const { data } = await this.r.get(`/roles`, { params: { page } });
     return data.data.map((r) => r.attributes);
   };
-  autoAssign = async () => {
-    const { data } = await this.r.post(`/servers/${this.id}/network/allocations`);
+  info = async (id) => {
+    const { data } = await this.r.get(
+      `/roles/${id}`
+    );
     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;
+  create = async (opts) => {
+    await this.r.post(`/roles`, opts);
   };
-  setPrimary = async (alloc_id) => {
-    const { data } = await this.r.post(`/servers/${this.id}/network/allocations/${alloc_id}/primary`);
-    return data.attributes;
+  update = async (id, opts) => {
+    await this.r.patch(`/roles/${id}`, opts);
   };
-  unassign = async (alloc_id) => {
-    await this.r.delete(
-      `/servers/${this.id}/network/allocations/${alloc_id}`
-    );
+  delete = async (id) => {
+    await this.r.delete(`/roles/${id}`);
   };
 };
 
-// src/api/client/server_users.ts
-var ServerUsers = class {
+// src/api/application/servers.ts
+var import_zod6 = __toESM(require("zod"));
+
+// src/api/application/servers_databases.ts
+var import_zod5 = __toESM(require("zod"));
+var ServersDatabases = class {
   r;
   id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
+  constructor(r, server_id) {
+    this.r = r;
+    this.id = server_id;
   }
   list = async () => {
-    const { data } = await this.r.get(`/servers/${this.id}/users`);
+    const { data } = await this.r.get(`/servers/${this.id}/databases`);
     return data.data.map((d) => d.attributes);
   };
-  create = async (email, permissions) => {
-    const { data } = await this.r.post(`/servers/${this.id}/users`, { email, permissions });
+  create = async (database, remote, host) => {
+    database = import_zod5.default.string().min(1).max(48).parse(database);
+    const { data } = await this.r.post(`/servers/${this.id}/databases`, { database, remote, host });
     return data.attributes;
   };
-  info = async (user_uuid) => {
-    const { data } = await this.r.get(
-      `/servers/${this.id}/users/${user_uuid}`
-    );
+  info = async (database_id) => {
+    const { data } = await this.r.get(`/servers/${this.id}/databases/${database_id}`);
     return data.attributes;
   };
-  update = async (user_uuid, permissions) => {
-    const { data } = await this.r.put(
-      `/servers/${this.id}/users/${user_uuid}`,
-      { permissions }
-    );
-    return data.attributes;
+  delete = async (database_id) => {
+    await this.r.delete(`/servers/${this.id}/databases/${database_id}`);
   };
-  delete = async (user_uuid) => {
-    await this.r.delete(`/servers/${this.id}/users/${user_uuid}`);
+  resetPassword = async (database_id) => {
+    await this.r.post(
+      `/servers/${this.id}/databases/${database_id}/reset-password`
+    );
   };
 };
 
-// src/api/client/server_backups.ts
-var import_axios2 = __toESM(require("axios"));
-var import_zod3 = __toESM(require("zod"));
-var ServerBackups = class {
+// src/api/application/servers.ts
+var Servers = class {
   r;
   id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
+  databases;
+  constructor(r, server_id) {
+    this.r = r;
+    this.id = server_id;
+    this.databases = new ServersDatabases(this.r, this.id);
   }
-  list = async (page = 1) => {
-    import_zod3.default.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 = import_zod3.default.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")
-    });
+  info = async (include) => {
+    const { data } = await this.r.get(`/servers/${this.id}`, { params: { include: include?.join(",") } });
     return data.attributes;
   };
-  info = async (backup_uuid) => {
-    const { data } = await this.r.get(`/servers/${this.id}/backups/${backup_uuid}`);
-    return data.attributes;
+  delete = async (force = false) => {
+    await this.r.delete(`/servers/${this.id}${force ? "/force" : ""}`);
   };
-  downloadGetUrl = async (backup_uuid) => {
-    const { data } = await this.r.get(`/servers/${this.id}/backups/${backup_uuid}/download`);
-    return data.attributes.url;
+  updateDetails = async (opts) => {
+    opts = UpdateDetailsSchema.parse(opts);
+    await this.r.patch(`/servers/${this.id}/details`, opts);
   };
-  download = async (backup_uuid) => {
-    const url = await this.downloadGetUrl(backup_uuid);
-    const { data } = await import_axios2.default.get(url, {
-      responseType: "arraybuffer"
-    });
-    return data;
+  updateBuild = async (opts) => {
+    opts = UpdateBuildSchema.parse(opts);
+    await this.r.patch(`/servers/${this.id}/build`, opts);
   };
-  delete = async (backup_uuid) => {
-    await this.r.delete(`/servers/${this.id}/backups/${backup_uuid}`);
+  updateStartup = async (opts) => {
+    opts = UpdateStartupSchema.parse(opts);
+    await this.r.patch(`/servers/${this.id}/startup`, opts);
   };
-  rename = async (backup_uuid, name) => {
-    await this.r.put(`/servers/${this.id}/backups/${backup_uuid}/rename`, {
-      name
-    });
+  suspend = async () => {
+    await this.r.post(`/servers/${this.id}/suspend`);
   };
-  toggleLock = async (backup_uuid) => {
-    await this.r.post(`/servers/${this.id}/backups/${backup_uuid}/lock`);
+  unsuspend = async () => {
+    await this.r.post(`/servers/${this.id}/unsuspend`);
   };
-  restore = async (backup_uuid, truncate) => {
-    await this.r.post(
-      `/servers/${this.id}/backups/${backup_uuid}/restore`,
-      { truncate }
-    );
+  reinstall = async () => {
+    await this.r.post(`/servers/${this.id}/reinstall`);
   };
-};
-
-// 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)
-    };
+  transferStart = async (node_id, allocation_id, allocation_additional) => {
+    await this.r.post(`/servers/${this.id}/transfer`, {
+      node_id,
+      allocation_id,
+      allocation_additional
+    });
   };
-  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
-var import_zod4 = __toESM(require("zod"));
-var ServerSettings = class {
-  r;
-  id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
-  }
-  rename = async (name) => {
-    name = import_zod4.default.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.put(`/servers/${this.id}/settings/docker-image`, {
-      docker_image: image
-    });
+  transferCancel = async () => {
+    await this.r.post(`/servers/${this.id}/transfer/cancel`);
   };
 };
+var CreateServerSchema = import_zod6.default.object({
+  external_id: import_zod6.default.string().min(1).max(255).optional(),
+  name: import_zod6.default.string().min(1).max(255),
+  description: import_zod6.default.string().optional(),
+  user: import_zod6.default.number(),
+  egg: import_zod6.default.number(),
+  docker_image: import_zod6.default.string().optional(),
+  startup: import_zod6.default.string().optional(),
+  environment: import_zod6.default.record(import_zod6.default.string(), import_zod6.default.string()),
+  skip_scripts: import_zod6.default.boolean().optional(),
+  oom_killer: import_zod6.default.boolean().optional(),
+  start_on_completion: import_zod6.default.boolean().optional(),
+  docker_labels: import_zod6.default.record(import_zod6.default.string(), import_zod6.default.string()).optional(),
+  limits: import_zod6.default.object({
+    memory: import_zod6.default.number().min(0),
+    swap: import_zod6.default.number().min(-1),
+    disk: import_zod6.default.number().min(0),
+    io: import_zod6.default.number().min(0),
+    threads: import_zod6.default.string().optional(),
+    cpu: import_zod6.default.number().min(0)
+  }),
+  feature_limits: import_zod6.default.object({
+    databases: import_zod6.default.number().min(0),
+    allocations: import_zod6.default.number().min(0),
+    backups: import_zod6.default.number().min(0)
+  }),
+  allocation: import_zod6.default.object({
+    default: import_zod6.default.string().nullable(),
+    additional: import_zod6.default.array(import_zod6.default.string()).optional()
+  }).optional(),
+  deploy: import_zod6.default.object({
+    tags: import_zod6.default.array(import_zod6.default.string()).optional(),
+    dedicated_ip: import_zod6.default.boolean().optional(),
+    port_range: import_zod6.default.array(import_zod6.default.string()).optional()
+  }).optional()
+});
+var UpdateDetailsSchema = CreateServerSchema.pick({
+  external_id: true,
+  name: true,
+  user: true,
+  description: true,
+  docker_labels: true
+});
+var UpdateBuildSchema = CreateServerSchema.pick({
+  oom_killer: true,
+  limits: true,
+  feature_limits: true
+}).extend({
+  allocation: import_zod6.default.number().optional(),
+  add_allocations: import_zod6.default.array(import_zod6.default.string()).optional(),
+  remove_allocations: import_zod6.default.array(import_zod6.default.string()).optional()
+});
+var UpdateStartupSchema = CreateServerSchema.pick({
+  startup: true,
+  environment: true,
+  egg: true
+}).extend({ image: import_zod6.default.string().optional(), skip_scripts: import_zod6.default.boolean() });
 
-// src/api/client/server_websocket.ts
-var import_events = require("events");
-var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
-var import_strip_color = __toESM(require("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)"
+// src/api/application/users.ts
+var import_zod8 = __toESM(require("zod"));
+
+// src/api/common/types/enums.ts
+var import_zod7 = __toESM(require("zod"));
+var languagesSchema = import_zod7.default.enum([
+  "af",
+  "ak",
+  "am",
+  "ar",
+  "as",
+  "az",
+  "be",
+  "bg",
+  "bm",
+  "bn",
+  "bo",
+  "br",
+  "bs",
+  "ca",
+  "ce",
+  "cs",
+  "cv",
+  "cy",
+  "da",
+  "de",
+  "dz",
+  "ee",
+  "el",
+  "en",
+  "eo",
+  "es",
+  "et",
+  "eu",
+  "fa",
+  "ff",
+  "fi",
+  "fo",
+  "fr",
+  "fy",
+  "ga",
+  "gd",
+  "gl",
+  "gu",
+  "gv",
+  "ha",
+  "he",
+  "hi",
+  "hr",
+  "hu",
+  "hy",
+  "ia",
+  "id",
+  "ig",
+  "ii",
+  "is",
+  "it",
+  "ja",
+  "jv",
+  "ka",
+  "ki",
+  "kk",
+  "kl",
+  "km",
+  "kn",
+  "ko",
+  "ks",
+  "ku",
+  "kw",
+  "ky",
+  "lb",
+  "lg",
+  "ln",
+  "lo",
+  "lt",
+  "lu",
+  "lv",
+  "mg",
+  "mi",
+  "mk",
+  "ml",
+  "mn",
+  "mr",
+  "ms",
+  "mt",
+  "my",
+  "nb",
+  "nd",
+  "ne",
+  "nl",
+  "nn",
+  "no",
+  "om",
+  "or",
+  "os",
+  "pa",
+  "pl",
+  "ps",
+  "pt",
+  "qu",
+  "rm",
+  "rn",
+  "ro",
+  "ru",
+  "rw",
+  "sa",
+  "sc",
+  "sd",
+  "se",
+  "sg",
+  "si",
+  "sk",
+  "sl",
+  "sn",
+  "so",
+  "sq",
+  "sr",
+  "su",
+  "sv",
+  "sw",
+  "ta",
+  "te",
+  "tg",
+  "th",
+  "ti",
+  "tk",
+  "to",
+  "tr",
+  "tt",
+  "ug",
+  "uk",
+  "ur",
+  "uz",
+  "vi",
+  "wo",
+  "xh",
+  "yi",
+  "yo",
+  "zh",
+  "zu"
 ]);
-var FALLBACK_LOG_MESSAGE = "No logs - is the server online?";
-var ServerWebsocket = class {
-  r;
-  serverId;
-  socket;
-  currentToken;
-  bus = new import_events.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 import_isomorphic_ws.default(socketUrl) : new import_isomorphic_ws.default(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 = (0, import_strip_color.default)(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 = (0, import_strip_color.default)(output);
-        }
-        this.emit("daemon message" /* DAEMON_MESSAGE */, output);
-        break;
-      }
-      case "install output" /* INSTALL_OUTPUT */: {
-        let output = message.args[0];
-        if (this.stripColors) {
-          output = (0, import_strip_color.default)(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);
-  }
-  get $r() {
-    return this.r;
-  }
-  listPermissions = async () => {
-    const { data } = await this.r.get("/permissions");
-    return data.attributes.permissions;
-  };
-  listServers = async (type = "accessible", page = 1, per_page = 50, include) => {
-    import_zod5.default.number().positive().parse(page);
-    const { data } = await this.r.get("/", { 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
-var import_zod7 = __toESM(require("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/common/types/enums.ts
-var import_zod6 = __toESM(require("zod"));
-var languagesSchema = import_zod6.default.enum([
-  "af",
-  "ak",
-  "am",
-  "ar",
-  "as",
-  "az",
-  "be",
-  "bg",
-  "bm",
-  "bn",
-  "bo",
-  "br",
-  "bs",
-  "ca",
-  "ce",
-  "cs",
-  "cv",
-  "cy",
-  "da",
-  "de",
-  "dz",
-  "ee",
-  "el",
-  "en",
-  "eo",
-  "es",
-  "et",
-  "eu",
-  "fa",
-  "ff",
-  "fi",
-  "fo",
-  "fr",
-  "fy",
-  "ga",
-  "gd",
-  "gl",
-  "gu",
-  "gv",
-  "ha",
-  "he",
-  "hi",
-  "hr",
-  "hu",
-  "hy",
-  "ia",
-  "id",
-  "ig",
-  "ii",
-  "is",
-  "it",
-  "ja",
-  "jv",
-  "ka",
-  "ki",
-  "kk",
-  "kl",
-  "km",
-  "kn",
-  "ko",
-  "ks",
-  "ku",
-  "kw",
-  "ky",
-  "lb",
-  "lg",
-  "ln",
-  "lo",
-  "lt",
-  "lu",
-  "lv",
-  "mg",
-  "mi",
-  "mk",
-  "ml",
-  "mn",
-  "mr",
-  "ms",
-  "mt",
-  "my",
-  "nb",
-  "nd",
-  "ne",
-  "nl",
-  "nn",
-  "no",
-  "om",
-  "or",
-  "os",
-  "pa",
-  "pl",
-  "ps",
-  "pt",
-  "qu",
-  "rm",
-  "rn",
-  "ro",
-  "ru",
-  "rw",
-  "sa",
-  "sc",
-  "sd",
-  "se",
-  "sg",
-  "si",
-  "sk",
-  "sl",
-  "sn",
-  "so",
-  "sq",
-  "sr",
-  "su",
-  "sv",
-  "sw",
-  "ta",
-  "te",
-  "tg",
-  "th",
-  "ti",
-  "tk",
-  "to",
-  "tr",
-  "tt",
-  "ug",
-  "uk",
-  "ur",
-  "uz",
-  "vi",
-  "wo",
-  "xh",
-  "yi",
-  "yo",
-  "zh",
-  "zu"
-]);
-var timezonesSchema = import_zod6.default.enum([
+var timezonesSchema = import_zod7.default.enum([
   "Africa/Abidjan",
   "Africa/Accra",
   "Africa/Addis_Ababa",
@@ -1549,605 +1034,1122 @@ var timezonesSchema = import_zod6.default.enum([
   "UTC"
 ]);
 
-// src/api/application/users.ts
-var Users = class {
+// 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) => {
+    import_zod8.default.number().positive().parse(page);
+    const { data } = await this.r.get("/users", {
+      params: {
+        include: opts.include?.join(","),
+        page,
+        ...ArrayQueryParams({ filters: opts.filters || {} }),
+        sort: opts.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 }) => {
+    import_zod8.default.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}`, {
+      params: { include: include?.join(",") }
+    });
+    return data.attributes;
+  };
+  create = async (user) => {
+    user = CreateSchema.parse(user);
+    const { data } = await this.r.post("/users", user);
+    return data.attributes;
+  };
+  update = async (id, user) => {
+    user = CreateSchema.parse(user);
+    const { data } = await this.r.patch(`/users/${id}`, user);
+    return data.attributes;
+  };
+  delete = async (id) => {
+    import_zod8.default.number().positive().parse(id);
+    await this.r.delete(`/users/${id}`);
+  };
+  addRoles = async (id, roles) => {
+    import_zod8.default.number().positive().parse(id);
+    await this.r.patch(`/users/${id}/roles/assign`, { roles });
+  };
+  removeRoles = async (id, roles) => {
+    import_zod8.default.number().positive().parse(id);
+    await this.r.patch(`/users/${id}/roles/remove`, { roles });
+  };
+  apiKeys = {
+    list: async (id) => {
+      const { data } = await this.r.get(`/users/${id}/api-keys`);
+      return data.data.map((k) => k.attributes);
+    },
+    create: async (id, description, allowed_ips) => {
+      allowed_ips = import_zod8.default.array(import_zod8.default.ipv4()).optional().parse(allowed_ips);
+      const { data } = await this.r.post(`/users/${id}/api-keys`, { description, allowed_ips });
+      return { ...data.attributes, secret_token: data.meta.secret_token };
+    },
+    delete: async (id, identifier) => {
+      await this.r.delete(`/users/${id}/api-keys/${identifier}`);
+    }
+  };
+};
+var CreateSchema = import_zod8.default.object({
+  email: import_zod8.default.email(),
+  external_id: import_zod8.default.string().max(255).optional(),
+  username: import_zod8.default.string().min(1).max(255),
+  password: import_zod8.default.string().optional(),
+  language: languagesSchema,
+  timezone: timezonesSchema
+});
+
+// src/api/application/client.ts
+var Client = class {
+  r;
+  users;
+  nodes;
+  databaseHosts;
+  roles;
+  eggs;
+  mounts;
+  constructor(requester) {
+    this.r = requester;
+    this.users = new Users(requester);
+    this.nodes = new Nodes(requester);
+    this.databaseHosts = new DatabaseHosts(requester);
+    this.roles = new Roles(requester);
+    this.eggs = new Eggs(requester);
+    this.mounts = new Mounts(requester);
+  }
+  get $r() {
+    return this.r;
+  }
+  listServers = async (search, page = 1) => {
+    const { data } = await this.r.get("/servers", { params: { search, page } });
+    return data.data.map((s) => s.attributes);
+  };
+  createServer = async (opts) => {
+    opts = CreateServerSchema.parse(opts);
+    const { data } = await this.r.post("/servers", opts);
+    return data.attributes;
+  };
+  getServerByExternalId = async (external_id, include) => {
+    const { data } = await this.r.get(`/servers/external/${external_id}`, {
+      params: { include: include?.join(",") }
+    });
+    return data.attributes;
+  };
+  servers = (server_id) => new Servers(this.r, server_id);
+};
+
+// src/api/base/request.ts
+var import_axios = __toESM(require("axios"));
+var import_zod9 = __toESM(require("zod"));
+
+// 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, suffix = "/api") {
+    this.base_url = import_zod9.default.url("Invalid URL Schema").transform((url2) => new URL(url2).href).parse(url);
+    this.token = import_zod9.default.string().regex(/^(ptl[ac]|pacc|papp)_.+$/, "Invalid token type").parse(token);
+    this.requester = import_axios.default.create({
+      baseURL: this.base_url.replace(/\/+$/, "") + `${suffix}/${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/api/client/client.ts
+var import_zod14 = __toESM(require("zod"));
+
+// src/api/client/account.ts
+var import_zod10 = __toESM(require("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 = import_zod10.default.email().parse(newEmail);
+    await this.r.put("/account/email", { email: newEmail, password });
+  };
+  updatePassword = async (newPassword) => {
+    newPassword = import_zod10.default.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 = import_zod10.default.array(import_zod10.default.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.delete(`/account/ssh-keys/${fingerprint}`);
+    }
+  };
+};
+
+// 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_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_backups.ts
+var import_axios2 = __toESM(require("axios"));
+var import_zod11 = __toESM(require("zod"));
+var ServerBackups = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async (page = 1) => {
+    import_zod11.default.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 = import_zod11.default.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 import_axios2.default.get(url, {
+      responseType: "arraybuffer"
+    });
+    return data;
+  };
+  delete = async (backup_uuid) => {
+    await this.r.delete(`/servers/${this.id}/backups/${backup_uuid}`);
+  };
+  rename = async (backup_uuid, name) => {
+    await this.r.put(`/servers/${this.id}/backups/${backup_uuid}/rename`, {
+      name
+    });
+  };
+  toggleLock = async (backup_uuid) => {
+    await this.r.post(`/servers/${this.id}/backups/${backup_uuid}/lock`);
+  };
+  restore = async (backup_uuid, truncate) => {
+    await this.r.post(
+      `/servers/${this.id}/backups/${backup_uuid}/restore`,
+      { truncate }
+    );
+  };
+};
+
+// src/api/client/server_databases.ts
+var import_zod12 = __toESM(require("zod"));
+var ServerDatabases = class {
+  r;
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  list = async (include, page = 1) => {
+    import_zod12.default.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
+var import_axios3 = __toESM(require("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 import_axios3.default.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) => {
+    const { data } = await this.r.post(`/servers/${this.id}/files/compress`, {
+      root,
+      files,
+      archive_name,
+      extension
+    });
+    return data.attributes;
+  };
+  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 import_axios3.default.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_settings.ts
+var import_zod13 = __toESM(require("zod"));
+var ServerSettings = class {
   r;
-  constructor(requester) {
+  id;
+  constructor(requester, id) {
+    this.r = requester;
+    this.id = id;
+  }
+  rename = async (name) => {
+    name = import_zod13.default.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.put(`/servers/${this.id}/settings/docker-image`, {
+      docker_image: image
+    });
+  };
+};
+
+// 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_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_uuid) => {
+    const { data } = await this.r.get(
+      `/servers/${this.id}/users/${user_uuid}`
+    );
+    return data.attributes;
+  };
+  update = async (user_uuid, permissions) => {
+    const { data } = await this.r.put(
+      `/servers/${this.id}/users/${user_uuid}`,
+      { permissions }
+    );
+    return data.attributes;
+  };
+  delete = async (user_uuid) => {
+    await this.r.delete(`/servers/${this.id}/users/${user_uuid}`);
+  };
+};
+
+// src/api/client/server_websocket.ts
+var import_events = require("events");
+var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
+var import_strip_color = __toESM(require("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 import_events.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 import_isomorphic_ws.default(socketUrl) : new import_isomorphic_ws.default(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);
+        }
+      };
+    }
   }
-  list = async (opts, page = 1) => {
-    import_zod7.default.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)
+  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);
       }
-    });
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id, { include }) => {
-    import_zod7.default.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}`, {
-      params: { include: include?.join(",") }
-    });
-    return data.attributes;
-  };
-  create = async (user) => {
-    user = CreateSchema.parse(user);
-    const { data } = await this.r.post("/users", user);
-    return data.attributes;
-  };
-  update = async (id, user) => {
-    user = CreateSchema.parse(user);
-    const { data } = await this.r.patch(`/users/${id}`, user);
-    return data.attributes;
-  };
-  delete = async (id) => {
-    import_zod7.default.number().positive().parse(id);
-    await this.r.delete(`/users/${id}`);
-  };
-  addRoles = async (id, roles) => {
-    import_zod7.default.number().positive().parse(id);
-    await this.r.patch(`/users/${id}/roles/assign`, { roles });
-  };
-  removeRoles = async (id, roles) => {
-    import_zod7.default.number().positive().parse(id);
-    await this.r.patch(`/users/${id}/roles/remove`, { roles });
-  };
-  apiKeys = {
-    list: async (id) => {
-      const { data } = await this.r.get(`/users/${id}/api-keys`);
-      return data.data.map((k) => k.attributes);
-    },
-    create: async (id, description, allowed_ips) => {
-      allowed_ips = import_zod7.default.array(import_zod7.default.ipv4()).optional().parse(allowed_ips);
-      const { data } = await this.r.post(`/users/${id}/api-keys`, { description, allowed_ips });
-      return { ...data.attributes, secret_token: data.meta.secret_token };
-    },
-    delete: async (id, identifier) => {
-      await this.r.delete(`/users/${id}/api-keys/${identifier}`);
     }
-  };
-};
-var CreateSchema = import_zod7.default.object({
-  email: import_zod7.default.email(),
-  external_id: import_zod7.default.string().max(255).optional(),
-  username: import_zod7.default.string().min(1).max(255),
-  password: import_zod7.default.string().optional(),
-  language: languagesSchema,
-  timezone: timezonesSchema
-});
-
-// src/api/application/nodes_allocations.ts
-var import_zod8 = __toESM(require("zod"));
-var NodesAllocations = class {
-  r;
-  id;
-  constructor(requester, id) {
-    this.r = requester;
-    this.id = id;
   }
-  list = async (include) => {
-    const { data } = await this.r.get(`/nodes/${this.id}/allocations`, {
-      params: { include: include?.join(",") }
-    });
-    return data.data.map((d) => d.attributes);
-  };
-  create = async (ip, ports, alias) => {
-    import_zod8.default.ipv4().parse(ip);
-    import_zod8.default.ipv4().or(import_zod8.default.url().max(255)).optional().parse(alias);
-    import_zod8.default.array(import_zod8.default.number()).or(import_zod8.default.string().regex(/\d+-\d+/)).parse(ports);
-    await this.r.post(`/nodes/${this.id}/allocations`, { ip, ports, alias });
-  };
-  delete = async (alloc_id) => {
-    await this.r.delete(`/nodes/${this.id}/allocations/${alloc_id}`);
-  };
-};
-
-// src/api/application/nodes.ts
-var import_zod9 = __toESM(require("zod"));
-var Nodes = class {
-  r;
-  constructor(requester) {
-    this.r = requester;
+  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;
+    }
   }
-  list = async (include, page = 1) => {
-    import_zod9.default.number().positive().parse(page);
-    const { data } = await this.r.get("/nodes", { params: { include: include?.join(","), page } });
-    return data.data.map((s) => s.attributes);
-  };
-  listDeployable = async (filters, include, page = 1) => {
-    import_zod9.default.number().positive().parse(page);
-    const { data } = await this.r.get("/nodes/deployable", {
-      params: {
-        include: include?.join(","),
-        disk: filters.disk,
-        memory: filters.memory,
-        cpu: filters.cpu,
-        location_ids: filters.location_ids,
-        tags: filters.tags,
-        page
+  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 = (0, import_strip_color.default)(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 = (0, import_strip_color.default)(output);
+        }
+        this.emit("daemon message" /* DAEMON_MESSAGE */, output);
+        break;
+      }
+      case "install output" /* INSTALL_OUTPUT */: {
+        let output = message.args[0];
+        if (this.stripColors) {
+          output = (0, import_strip_color.default)(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;
       }
-    });
-    return data.data.map((s) => s.attributes);
-  };
-  info = async (id, include) => {
-    import_zod9.default.number().positive().parse(id);
-    const { data } = await this.r.get(
-      `/nodes/${id}`,
-      { params: { include: include?.join(",") } }
-    );
-    return data.attributes;
-  };
-  create = async (node) => {
-    node = NodeCreateSchema.parse(node);
-    const { data } = await this.r.post(
-      "/nodes",
-      node
-    );
-    return data.attributes;
-  };
-  get_configuration = async (id) => {
-    import_zod9.default.number().positive().parse(id);
+      default: {
+        if (this.debugLogging) {
+          console.warn("Unknown websocket event", message);
+        }
+        break;
+      }
+    }
+  }
+  async refreshCredentials() {
     const { data } = await this.r.get(
-      `/nodes/${id}/configuration`
-    );
-    return data;
-  };
-  update = async (id, node) => {
-    import_zod9.default.number().positive().parse(id);
-    node = NodeCreateSchema.parse(node);
-    const { data } = await this.r.patch(
-      `/nodes/${id}`,
-      node
+      `/servers/${this.serverId}/websocket`
     );
-    return data.attributes;
-  };
-  delete = async (id) => {
-    import_zod9.default.number().positive().parse(id);
-    await this.r.delete(`/nodes/${id}`);
-  };
-  allocations = (server_id) => new NodesAllocations(this.r, server_id);
-};
-var NodeCreateSchema = import_zod9.default.object({
-  name: import_zod9.default.string().min(1).max(100),
-  description: import_zod9.default.string().optional(),
-  public: import_zod9.default.boolean().optional(),
-  fqdn: import_zod9.default.string().nonempty(),
-  scheme: import_zod9.default.enum(["http", "https"]),
-  behind_proxy: import_zod9.default.boolean().optional(),
-  memory: import_zod9.default.number().min(0),
-  memory_overallocate: import_zod9.default.number().min(-1),
-  disk: import_zod9.default.number().min(0),
-  disk_overallocate: import_zod9.default.number().min(-1),
-  cpu: import_zod9.default.number().min(0),
-  cpu_overallocate: import_zod9.default.number().min(-1),
-  daemon_base: import_zod9.default.string().nonempty().optional(),
-  daemon_sftp: import_zod9.default.number().min(1).max(65535),
-  daemon_sftp_alias: import_zod9.default.string().optional(),
-  daemon_listen: import_zod9.default.number().min(1).max(65535),
-  daemon_connect: import_zod9.default.number().min(1).max(65535),
-  maintenance_mode: import_zod9.default.boolean().optional(),
-  upload_size: import_zod9.default.number().min(1).max(1024),
-  tags: import_zod9.default.array(import_zod9.default.string()).optional()
-});
-
-// src/api/application/servers.ts
-var import_zod11 = __toESM(require("zod"));
-
-// src/api/application/servers_databases.ts
-var import_zod10 = __toESM(require("zod"));
-var ServersDatabases = class {
-  r;
-  id;
-  constructor(r, server_id) {
-    this.r = r;
-    this.id = server_id;
+    this.currentToken = data.data.token;
+    return data.data.socket;
   }
-  list = async () => {
-    const { data } = await this.r.get(`/servers/${this.id}/databases`);
-    return data.data.map((d) => d.attributes);
-  };
-  create = async (database, remote, host) => {
-    database = import_zod10.default.string().min(1).max(48).parse(database);
-    const { data } = await this.r.post(`/servers/${this.id}/databases`, { database, remote, host });
-    return data.attributes;
-  };
-  info = async (database_id) => {
-    const { data } = await this.r.get(`/servers/${this.id}/databases/${database_id}`);
-    return data.attributes;
-  };
-  delete = async (database_id) => {
-    await this.r.delete(`/servers/${this.id}/databases/${database_id}`);
-  };
-  resetPassword = async (database_id) => {
-    await this.r.post(
-      `/servers/${this.id}/databases/${database_id}/reset-password`
+  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] })
     );
-  };
-};
-
-// src/api/application/servers.ts
-var Servers = class {
-  r;
-  id;
-  databases;
-  constructor(r, server_id) {
-    this.r = r;
-    this.id = server_id;
-    this.databases = new ServersDatabases(this.r, this.id);
   }
-  info = async (include) => {
-    const { data } = await this.r.get(`/servers/${this.id}`, { params: { include: include?.join(",") } });
-    return data.attributes;
-  };
-  delete = async (force = false) => {
-    await this.r.delete(`/servers/${this.id}${force ? "/force" : ""}`);
-  };
-  updateDetails = async (opts) => {
-    opts = UpdateDetailsSchema.parse(opts);
-    await this.r.patch(`/servers/${this.id}/details`, opts);
-  };
-  updateBuild = async (opts) => {
-    opts = UpdateBuildSchema.parse(opts);
-    await this.r.patch(`/servers/${this.id}/build`, opts);
-  };
-  updateStartup = async (opts) => {
-    opts = UpdateStartupSchema.parse(opts);
-    await this.r.patch(`/servers/${this.id}/startup`, opts);
-  };
-  suspend = async () => {
-    await this.r.post(`/servers/${this.id}/suspend`);
-  };
-  unsuspend = async () => {
-    await this.r.post(`/servers/${this.id}/unsuspend`);
-  };
-  reinstall = async () => {
-    await this.r.post(`/servers/${this.id}/reinstall`);
-  };
-  transferStart = async (node_id, allocation_id, allocation_additional) => {
-    await this.r.post(`/servers/${this.id}/transfer`, {
-      node_id,
-      allocation_id,
-      allocation_additional
-    });
-  };
-  transferCancel = async () => {
-    await this.r.post(`/servers/${this.id}/transfer/cancel`);
-  };
-};
-var CreateServerSchema = import_zod11.default.object({
-  external_id: import_zod11.default.string().min(1).max(255).optional(),
-  name: import_zod11.default.string().min(1).max(255),
-  description: import_zod11.default.string().optional(),
-  user: import_zod11.default.number(),
-  egg: import_zod11.default.number(),
-  docker_image: import_zod11.default.string().optional(),
-  startup: import_zod11.default.string().optional(),
-  environment: import_zod11.default.record(import_zod11.default.string(), import_zod11.default.string()),
-  skip_scripts: import_zod11.default.boolean().optional(),
-  oom_killer: import_zod11.default.boolean().optional(),
-  start_on_completion: import_zod11.default.boolean().optional(),
-  docker_labels: import_zod11.default.record(import_zod11.default.string(), import_zod11.default.string()).optional(),
-  limits: import_zod11.default.object({
-    memory: import_zod11.default.number().min(0),
-    swap: import_zod11.default.number().min(-1),
-    disk: import_zod11.default.number().min(0),
-    io: import_zod11.default.number().min(0),
-    threads: import_zod11.default.string().optional(),
-    cpu: import_zod11.default.number().min(0)
-  }),
-  feature_limits: import_zod11.default.object({
-    databases: import_zod11.default.number().min(0),
-    allocations: import_zod11.default.number().min(0),
-    backups: import_zod11.default.number().min(0)
-  }),
-  allocation: import_zod11.default.object({
-    default: import_zod11.default.string(),
-    additional: import_zod11.default.array(import_zod11.default.string()).optional()
-  }).optional(),
-  deploy: import_zod11.default.object({
-    tags: import_zod11.default.array(import_zod11.default.string()).optional(),
-    dedicated_ip: import_zod11.default.boolean().optional(),
-    port_range: import_zod11.default.array(import_zod11.default.string()).optional()
-  }).optional()
-});
-var UpdateDetailsSchema = CreateServerSchema.pick({
-  external_id: true,
-  name: true,
-  user: true,
-  description: true,
-  docker_labels: true
-});
-var UpdateBuildSchema = CreateServerSchema.pick({
-  oom_killer: true,
-  limits: true,
-  feature_limits: true
-}).extend({
-  allocation: import_zod11.default.number().optional(),
-  add_allocations: import_zod11.default.array(import_zod11.default.string()).optional(),
-  remove_allocations: import_zod11.default.array(import_zod11.default.string()).optional()
-});
-var UpdateStartupSchema = CreateServerSchema.pick({
-  startup: true,
-  environment: true,
-  egg: true
-}).extend({ image: import_zod11.default.string().optional(), skip_scripts: import_zod11.default.boolean() });
-
-// src/api/application/database_hosts.ts
-var import_zod12 = __toESM(require("zod"));
-var DatabaseHosts = class {
-  r;
-  constructor(r) {
-    this.r = r;
+  disconnect() {
+    this.detachMessageListener?.();
+    this.detachMessageListener = void 0;
+    if (this.socket) {
+      this.socket.close();
+      this.socket = void 0;
+    }
   }
-  list = async (page = 1) => {
-    const { data } = await this.r.get("/database-hosts", { params: { page } });
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id) => {
-    const { data } = await this.r.get(`/database-hosts/${id}`);
-    return data.attributes;
-  };
-  // TODO: find out why API returns 500
-  create = async (opts) => {
-    opts = CreateDBHostSchema.parse(opts);
-    await this.r.post(
-      "/database-hosts",
-      opts
-    ).catch((e) => {
-    });
-  };
-  update = async (id, opts) => {
-    opts = CreateDBHostSchema.parse(opts);
-    const { data } = await this.r.patch(`/database-hosts/${id}`, opts);
-    return data.attributes;
-  };
-  delete = async (id) => {
-    await this.r.delete(`/database-hosts/${id}`);
-  };
-};
-var CreateDBHostSchema = import_zod12.default.object({
-  name: import_zod12.default.string().min(1).max(255),
-  host: import_zod12.default.string(),
-  port: import_zod12.default.number().min(1).max(65535),
-  username: import_zod12.default.string().min(1).max(255),
-  password: import_zod12.default.string().optional(),
-  node_ids: import_zod12.default.array(import_zod12.default.string()).optional(),
-  max_databases: import_zod12.default.number().optional()
-});
-
-// src/api/application/roles.ts
-var Roles = class {
-  r;
-  constructor(r) {
-    this.r = r;
+  requestStats() {
+    this.send("send stats", [null]);
   }
-  list = async (page = 1) => {
-    const { data } = await this.r.get(`/roles`, { params: { page } });
-    return data.data.map((r) => r.attributes);
-  };
-  info = async (id) => {
-    const { data } = await this.r.get(
-      `/roles/${id}`
-    );
-    return data.attributes;
-  };
-  create = async (opts) => {
-    await this.r.post(`/roles`, opts);
-  };
-  update = async (id, opts) => {
-    await this.r.patch(`/roles/${id}`, opts);
-  };
-  delete = async (id) => {
-    await this.r.delete(`/roles/${id}`);
-  };
-};
-
-// src/api/application/eggs.ts
-var Eggs = class {
-  r;
-  constructor(r) {
-    this.r = r;
+  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 }));
   }
-  list = async () => {
-    const { data } = await this.r.get(
-      "/eggs"
-    );
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id) => {
-    const { data } = await this.r.get(
-      `/eggs/${id}`
-    );
-    return data.attributes;
-  };
-  export = async (id, format) => {
-    const { data } = await this.r.get(`/eggs/${id}/export`, {
-      params: { format },
-      transformResponse: (r) => r
+  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();
     });
-    return data;
-  };
-  infoExportable = async (id) => {
-    const { data } = await this.r.get(`/eggs/${id}/export`, {
-      params: { format: "json" }
+  }
+  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();
     });
-    return data;
-  };
+  }
+  sendPoweraction(action) {
+    this.send("set state", [action]);
+  }
+  sendCommand(cmd) {
+    this.send("send command", [cmd]);
+  }
 };
 
-// src/api/application/mounts.ts
-var import_zod13 = __toESM(require("zod"));
-var Mounts = class {
+// src/api/client/server.ts
+var ServerClient = class {
   r;
-  constructor(r) {
-    this.r = 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);
   }
-  list = async () => {
-    const { data } = await this.r.get("/mounts");
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id) => {
+  info = async (include) => {
     const { data } = await this.r.get(
-      `/mounts/${id}`
+      `/servers/${this.id}`,
+      { params: { include: include?.join(",") } }
     );
     return data.attributes;
   };
-  create = async (opts) => {
-    opts = CreateMountSchema.parse(opts);
-    const { data } = await this.r.post(
-      "/mounts",
-      opts
-    );
-    return data.attributes;
+  websocket = (stripColors = false) => {
+    return new ServerWebsocket(this.r, this.id, stripColors);
   };
-  update = async (id, opts) => {
-    opts = CreateMountSchema.parse(opts);
-    const { data } = await this.r.patch(
-      `/mounts/${id}`,
-      opts
+  resources = async () => {
+    const { data } = await this.r.get(
+      `/servers/${this.id}/resources`
     );
     return data.attributes;
   };
-  delete = async (id) => {
-    await this.r.delete(`/mounts/${id}`);
-  };
-  listAssignedEggs = async (id) => {
-    const { data } = await this.r.get(`/mounts/${id}/eggs`);
-    return data.data.map((d) => d.attributes);
-  };
-  assignEggs = async (id, eggs) => {
-    await this.r.post(`/mounts/${id}/eggs`, { eggs });
-  };
-  unassignEgg = async (id, egg_id) => {
-    await this.r.delete(`/mounts/${id}/eggs/${egg_id}`);
-  };
-  listAssignedNodes = async (id) => {
-    const { data } = await this.r.get(`/mounts/${id}/nodes`);
-    return data.data.map((d) => d.attributes);
-  };
-  assignNodes = async (id, nodes) => {
-    await this.r.post(`/mounts/${id}/nodes`, { nodes });
-  };
-  unassignNode = async (id, node_id) => {
-    await this.r.delete(`/mounts/${id}/nodes/${node_id}`);
-  };
-  listAssignedServers = async (id) => {
-    const { data } = await this.r.get(`/mounts/${id}/servers`);
-    return data.data.map((d) => d.attributes);
-  };
-  assignServers = async (id, servers) => {
-    await this.r.post(`/mounts/${id}/servers`, { servers });
+  command = async (command) => {
+    await this.r.post(`/servers/${this.id}/command`, { command });
   };
-  unassignServer = async (id, server_id) => {
-    await this.r.delete(`/mounts/${id}/servers/${server_id}`);
+  power = async (signal) => {
+    await this.r.post(`/servers/${this.id}/power`, { signal });
   };
 };
-var CreateMountSchema = import_zod13.default.object({
-  name: import_zod13.default.string().min(1).max(255),
-  description: import_zod13.default.string().optional(),
-  source: import_zod13.default.string(),
-  target: import_zod13.default.string(),
-  read_only: import_zod13.default.boolean().optional()
-});
 
-// src/api/application/client.ts
+// src/api/client/client.ts
 var Client2 = class {
+  account;
   r;
-  users;
-  nodes;
-  databaseHosts;
-  roles;
-  eggs;
-  mounts;
   constructor(requester) {
     this.r = requester;
-    this.users = new Users(requester);
-    this.nodes = new Nodes(requester);
-    this.databaseHosts = new DatabaseHosts(requester);
-    this.roles = new Roles(requester);
-    this.eggs = new Eggs(requester);
-    this.mounts = new Mounts(requester);
+    this.account = new Account(requester);
   }
   get $r() {
     return this.r;
   }
-  listServers = async (search, page = 1) => {
-    const { data } = await this.r.get("/servers", { params: { search, page } });
-    return data.data.map((s) => s.attributes);
-  };
-  createServer = async (opts) => {
-    opts = CreateServerSchema.parse(opts);
-    const { data } = await this.r.post("/servers", opts);
-    return data.attributes;
+  listPermissions = async () => {
+    const { data } = await this.r.get("/permissions");
+    return data.attributes.permissions;
   };
-  getServerByExternalId = async (external_id, include) => {
-    const { data } = await this.r.get(`/servers/external/${external_id}`, {
-      params: { include: include?.join(",") }
-    });
-    return data.attributes;
+  listServers = async (type = "accessible", page = 1, per_page = 50, include) => {
+    import_zod14.default.number().positive().parse(page);
+    const { data } = await this.r.get("/", { params: { type, page, include: include?.join(",") } });
+    return data.data.map((s) => s.attributes);
   };
-  servers = (server_id) => new Servers(this.r, server_id);
-};
-
-// src/api/base/request.ts
-var import_zod14 = __toESM(require("zod"));
-var import_axios3 = __toESM(require("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, suffix = "/api") {
-    this.base_url = import_zod14.default.url("Invalid URL Schema").transform((url2) => new URL(url2).href).parse(url);
-    this.token = import_zod14.default.string().regex(/^(ptl[ac]|pacc|papp)_.+$/, "Invalid token type").parse(token);
-    this.requester = import_axios3.default.create({
-      baseURL: this.base_url.replace(/\/+$/, "") + `${suffix}/${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);
-    });
-  }
+  server = (uuid) => new ServerClient(this.r, uuid);
 };
 
 // src/api/index.ts
-var PelicanAPIClient = class extends Client {
+var PelicanAPIClient = class extends Client2 {
   constructor(url, token, suffix = "/api") {
     const ax = new Agent(url, token, "client", suffix);
     super(ax.requester);
   }
 };
-var PelicanAPIApplication = class extends Client2 {
+var PelicanAPIApplication = class extends Client {
   constructor(url, token, suffix = "/api") {
     const ax = new Agent(url, token, "application", suffix);
     super(ax.requester);