@pelican.ts/sdk 0.3.4-next.4 → 0.4.1

package/dist/index.mjs

@@ -103,29 +103,29 @@ var ServerFiles = class {
     this.r = requester;
     this.id = id;
   }
-  list = async (path) => {
+  list = async (path2) => {
     const { data } = await this.r.get(`/servers/${this.id}/files/list`, {
-      params: { directory: path }
+      params: { directory: path2 }
     });
     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) => {
+  contents = async (path2) => {
     const { data } = await this.r.get(`/servers/${this.id}/files/contents`, {
-      params: { file: path }
+      params: { file: path2 }
     });
     return data;
   };
-  downloadGetUrl = async (path) => {
+  downloadGetUrl = async (path2) => {
     const { data } = await this.r.get(`/servers/${this.id}/files/download`, {
-      params: { file: path }
+      params: { file: path2 }
     });
     return data.attributes.url;
   };
-  download = async (path) => {
-    const url = await this.downloadGetUrl(path);
+  download = async (path2) => {
+    const url = await this.downloadGetUrl(path2);
     const { data } = await axios.get(url, { responseType: "arraybuffer" });
     return data;
   };
@@ -135,9 +135,9 @@ var ServerFiles = class {
   copy = async (location) => {
     await this.r.post(`/servers/${this.id}/files/copy`, { location });
   };
-  write = async (path, content) => {
+  write = async (path2, content) => {
     await this.r.post(`/servers/${this.id}/files/write`, content, {
-      params: { file: path }
+      params: { file: path2 }
     });
   };
   compress = async (root = "/", files, archive_name, extension) => {
@@ -884,21 +884,6 @@ var Client = class {
 // src/api/application/users.ts
 import z7 from "zod";
 
-// src/utils/transform.ts
-var ArrayQueryParams = (p) => {
-  const params = new URLSearchParams();
-  const o = {};
-  for (const [param, value] of Object.entries(p)) {
-    for (const [key, val] of Object.entries(value)) {
-      o[`${param}[${key}]`] = val;
-    }
-  }
-  return o;
-};
-var SortParam = (key, p) => {
-  return `${p === "desc" ? "-" : ""}${key}`;
-};
-
 // src/api/common/types/enums.ts
 import z6 from "zod";
 var languagesSchema = z6.enum([
@@ -1460,73 +1445,6 @@ var timezonesSchema = z6.enum([
 ]);
 
 // src/api/application/users.ts
-var Users = class {
-  r;
-  constructor(requester) {
-    this.r = requester;
-  }
-  list = async (opts, page = 1) => {
-    z7.number().positive().parse(page);
-    const { data } = await this.r.get("/users", {
-      params: {
-        include: opts.include?.join(","),
-        page,
-        ...ArrayQueryParams({ filters: opts.filters || {} }),
-        sort: opts.sort?.id ? SortParam("id", opts.sort?.id) : SortParam("uuid", opts.sort?.uuid)
-      }
-    });
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id, { include }) => {
-    z7.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) => {
-    z7.number().positive().parse(id);
-    await this.r.delete(`/users/${id}`);
-  };
-  addRoles = async (id, roles) => {
-    z7.number().positive().parse(id);
-    await this.r.patch(`/users/${id}/roles/assign`, { roles });
-  };
-  removeRoles = async (id, roles) => {
-    z7.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 = z7.array(z7.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 = z7.object({
   email: z7.email(),
   external_id: z7.string().max(255).optional(),
@@ -1538,92 +1456,9 @@ var CreateSchema = z7.object({
 
 // src/api/application/nodes_allocations.ts
 import z8 from "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) => {
-    z8.ipv4().parse(ip);
-    z8.ipv4().or(z8.url().max(255)).optional().parse(alias);
-    z8.array(z8.number()).or(z8.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
 import z9 from "zod";
-var Nodes = class {
-  r;
-  constructor(requester) {
-    this.r = requester;
-  }
-  list = async (include, page = 1) => {
-    z9.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) => {
-    z9.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) => {
-    z9.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) => {
-    z9.number().positive().parse(id);
-    const { data } = await this.r.get(`/nodes/${id}/configuration`);
-    return data;
-  };
-  update = async (id, node) => {
-    z9.number().positive().parse(id);
-    node = NodeCreateSchema.parse(node);
-    const { data } = await this.r.patch(`/nodes/${id}`, node);
-    return data.attributes;
-  };
-  delete = async (id) => {
-    z9.number().positive().parse(id);
-    await this.r.delete(`/nodes/${id}`);
-  };
-  allocations = (server_id) => new NodesAllocations(this.r, server_id);
-};
 var NodeCreateSchema = z9.object({
   name: z9.string().min(1).max(100),
   description: z9.string().optional(),
@@ -1652,85 +1487,8 @@ import z11 from "zod";
 
 // src/api/application/servers_databases.ts
 import z10 from "zod";
-var ServersDatabases = class {
-  r;
-  id;
-  constructor(r, server_id) {
-    this.r = r;
-    this.id = server_id;
-  }
-  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 = z10.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`);
-  };
-};
 
 // 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 = z11.object({
   external_id: z11.string().min(1).max(255).optional(),
   name: z11.string().min(1).max(255),
@@ -1794,36 +1552,6 @@ var UpdateStartupSchema = CreateServerSchema.pick({
 
 // src/api/application/database_hosts.ts
 import z12 from "zod";
-var DatabaseHosts = class {
-  r;
-  constructor(r) {
-    this.r = r;
-  }
-  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 = z12.object({
   name: z12.string().min(1).max(255),
   host: z12.string(),
@@ -1834,119 +1562,8 @@ var CreateDBHostSchema = z12.object({
   max_databases: z12.number().optional()
 });
 
-// src/api/application/roles.ts
-var Roles = class {
-  r;
-  constructor(r) {
-    this.r = r;
-  }
-  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;
-  }
-  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
-    });
-    return data;
-  };
-  infoExportable = async (id) => {
-    const { data } = await this.r.get(`/eggs/${id}/export`, { params: { format: "json" } });
-    return data;
-  };
-};
-
 // src/api/application/mounts.ts
 import z13 from "zod";
-var Mounts = class {
-  r;
-  constructor(r) {
-    this.r = r;
-  }
-  list = async () => {
-    const { data } = await this.r.get("/mounts");
-    return data.data.map((d) => d.attributes);
-  };
-  info = async (id) => {
-    const { data } = await this.r.get(`/mounts/${id}`);
-    return data.attributes;
-  };
-  create = async (opts) => {
-    opts = CreateMountSchema.parse(opts);
-    const { data } = await this.r.post("/mounts", opts);
-    return data.attributes;
-  };
-  update = async (id, opts) => {
-    opts = CreateMountSchema.parse(opts);
-    const { data } = await this.r.patch(`/mounts/${id}`, opts);
-    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 });
-  };
-  unassignServer = async (id, server_id) => {
-    await this.r.delete(`/mounts/${id}/servers/${server_id}`);
-  };
-};
 var CreateMountSchema = z13.object({
   name: z13.string().min(1).max(255),
   description: z13.string().optional(),
@@ -1955,47 +1572,6 @@ var CreateMountSchema = z13.object({
   read_only: z13.boolean().optional()
 });
 
-// src/api/application/client.ts
-var Client2 = 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
 import z14 from "zod";
 import axios3 from "axios";
@@ -2039,22 +1615,563 @@ var Agent = class {
   }
 };
 
-// src/index.ts
-var PelicanClient = class extends Client {
+// src/api/index.ts
+var PelicanAPIClient = class extends Client {
   constructor(url, token, suffix = "/api") {
     const ax = new Agent(url, token, "client", suffix);
     super(ax.requester);
   }
 };
-var PelicanApplication = class extends Client2 {
-  constructor(url, token, suffix = "/api") {
-    const ax = new Agent(url, token, "application", suffix);
-    super(ax.requester);
+
+// src/humane/Account.ts
+var Account2 = class {
+  client;
+  uuid;
+  username;
+  $email;
+  get email() {
+    return this.$email;
+  }
+  language;
+  image;
+  admin;
+  root_admin;
+  $has2faEnabled;
+  get has2faEnabled() {
+    return this.$has2faEnabled;
+  }
+  createdAt;
+  updatedAt;
+  constructor(client, user) {
+    this.client = client;
+    this.uuid = user.uuid;
+    this.username = user.username;
+    this.$email = user.email;
+    this.language = user.language;
+    this.image = user.image;
+    this.admin = user.admin;
+    this.root_admin = user.root_admin;
+    this.$has2faEnabled = user["2fa_enabled"];
+    this.createdAt = new Date(user.created_at);
+    this.updatedAt = new Date(user.updated_at);
+  }
+  updateEmail = async (newEmail, password) => {
+    await this.client.account.updateEmail(newEmail, password);
+    this.$email = newEmail;
+  };
+  updatePassword = async (newPassword) => this.client.account.updatePassword(newPassword);
+  listApiKeys = async () => this.client.account.apiKeys.list();
+  createApiKey = async (description, allowed_ips) => this.client.account.apiKeys.create(description, allowed_ips);
+  deleteApiKey = async (identifier) => this.client.account.apiKeys.delete(identifier);
+  listSshKeys = async () => this.client.account.sshKeys.list();
+  createSshKey = async (name, public_key) => this.client.account.sshKeys.create(name, public_key);
+  deleteSshKey = async (fingerprint) => this.client.account.sshKeys.delete(fingerprint);
+  get2faQR = async () => this.client.account.twoFactor.info();
+  enable2fa = async (code) => {
+    const tokens = await this.client.account.twoFactor.enable(code);
+    this.$has2faEnabled = true;
+    return tokens;
+  };
+  disable2fa = async (password) => {
+    await this.client.account.twoFactor.disable(password);
+    this.$has2faEnabled = false;
+  };
+};
+
+// src/humane/ServerAllocation.ts
+var ServerAllocation = class {
+  client;
+  alias;
+  id;
+  ip;
+  $isDefault;
+  get isDefault() {
+    return this.$isDefault;
+  }
+  $notes;
+  get notes() {
+    return this.$notes;
+  }
+  port;
+  constructor(client, alloc) {
+    this.client = client;
+    this.alias = alloc.alias;
+    this.id = alloc.id;
+    this.ip = alloc.ip;
+    this.$isDefault = alloc.is_default;
+    this.$notes = alloc.notes;
+    this.port = alloc.port;
+  }
+  setNotes = async (notes) => {
+    const data = await this.client.allocations.setNotes(this.id, notes);
+    this.$notes = data.notes;
+  };
+  makeDefault = async () => {
+    const data = await this.client.allocations.setPrimary(this.id);
+    this.$isDefault = data.is_default;
+  };
+  unassign = async () => this.client.allocations.unassign(this.id);
+};
+
+// src/humane/ServerBackup.ts
+var ServerBackup = class {
+  client;
+  bytes;
+  checksum;
+  completedAt;
+  createdAt;
+  ignoredFiles;
+  isLocked;
+  isSuccessful;
+  name;
+  uuid;
+  constructor(client, backup) {
+    this.client = client;
+    this.bytes = backup.bytes;
+    this.checksum = backup.checksum;
+    this.completedAt = backup.completed_at ? new Date(backup.completed_at) : null;
+    this.createdAt = new Date(backup.created_at);
+    this.ignoredFiles = backup.ignored_files;
+    this.isLocked = backup.is_locked;
+    this.isSuccessful = backup.is_successful;
+    this.name = backup.name;
+    this.uuid = backup.uuid;
+  }
+  downloadGetUrl = async () => this.client.backups.downloadGetUrl(this.uuid);
+  download = async () => this.client.backups.download(this.uuid);
+  delete = async () => this.client.backups.delete(this.uuid);
+};
+
+// src/humane/ServerDatabase.ts
+var ServerDatabase = class {
+  client;
+  allowConnectionsFrom;
+  host;
+  port;
+  id;
+  maxConnections;
+  name;
+  $password;
+  get password() {
+    return this.$password;
+  }
+  username;
+  constructor(client, database) {
+    this.client = client;
+    this.allowConnectionsFrom = database.connections_from;
+    this.host = database.host.address;
+    this.port = database.host.port;
+    this.id = database.id;
+    this.maxConnections = database.max_connections;
+    this.name = database.name;
+    this.$password = database.relationships?.password.attributes.password;
+    this.username = database.username;
+  }
+  rotatePassword = async () => {
+    const data = await this.client.databases.rotatePassword(this.id);
+    this.$password = data.relationships?.password.attributes.password;
+  };
+  delete = async () => this.client.databases.delete(this.id);
+};
+
+// src/humane/ServerFile.ts
+import path from "path";
+var ServerFile = class {
+  client;
+  dir;
+  path;
+  createdAt;
+  isFile;
+  isSymlink;
+  mimetype;
+  mode;
+  modeBits;
+  modifiedAt;
+  name;
+  size;
+  constructor(client, file, dir = "/") {
+    this.client = client;
+    this.dir = dir;
+    this.createdAt = new Date(file.created_at);
+    this.isFile = file.is_file;
+    this.isSymlink = file.is_symlink;
+    this.mimetype = file.mimetype;
+    this.mode = file.mode;
+    this.modeBits = file.mode_bits;
+    this.modifiedAt = new Date(file.modified_at);
+    this.name = file.name;
+    this.size = file.size;
+    this.path = path.join(dir, this.name);
+  }
+  get isArchive() {
+    return [
+      "zip",
+      "tgz",
+      "tar.gz",
+      "txz",
+      "tar.xz",
+      "tbz2",
+      "tar.bz2"
+    ].some((ext) => this.name.endsWith(`.${ext}`));
+  }
+  /**
+   * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
+   */
+  contents = async () => this.client.files.contents(this.path);
+  downloadGetUrl = async () => this.client.files.downloadGetUrl(this.path);
+  download = async () => this.client.files.download(this.path);
+  rename = async (newName) => this.client.files.rename(this.dir, [{ from: this.name, to: newName }]);
+  copy = async () => this.client.files.copy(this.path);
+  write = async (content) => this.client.files.write(this.path, content);
+  compress = async (archive_name, extension) => this.client.files.compress(
+    this.dir,
+    [this.name],
+    archive_name,
+    extension
+  );
+  decompress = async () => this.client.files.decompress(this.dir, this.name);
+  delete = async () => this.client.files.delete(this.dir, [this.name]);
+  chmod = async (mode) => this.client.files.chmod(this.dir, [{ file: this.name, mode }]);
+};
+
+// src/humane/ServerSchedule.ts
+var ServerSchedule = class {
+  client;
+  createdAt;
+  $cron;
+  get cron() {
+    return { ...this.$cron };
+  }
+  id;
+  $isActive;
+  get isActive() {
+    return this.$isActive;
+  }
+  $isProcessing;
+  get isProcessing() {
+    return this.$isProcessing;
+  }
+  lastRunAt;
+  $name;
+  get name() {
+    return this.$name;
+  }
+  nextRunAt;
+  $onlyWhenOnline;
+  get onlyWhenOnline() {
+    return this.$onlyWhenOnline;
+  }
+  tasks;
+  $updatedAt;
+  get updatedAt() {
+    return this.$updatedAt;
+  }
+  constructor(client, schedule) {
+    this.client = client;
+    this.createdAt = new Date(schedule.created_at);
+    this.$cron = schedule.cron;
+    this.id = schedule.id;
+    this.$isActive = schedule.is_active;
+    this.$isProcessing = schedule.is_processing;
+    this.lastRunAt = schedule.last_run_at ? new Date(schedule.last_run_at) : null;
+    this.$name = schedule.name;
+    this.nextRunAt = new Date(schedule.next_run_at);
+    this.$onlyWhenOnline = schedule.only_when_online;
+    this.tasks = schedule.relationships.tasks.data.map(
+      (d) => new ServerScheduleTask(this.client, this.id, d.attributes)
+    );
+    this.$updatedAt = new Date(schedule.updated_at);
+  }
+  update = async (opts) => {
+    const data = await this.client.schedules.control(this.id).update(opts);
+    this.$name = data.name;
+    this.$isActive = data.is_active;
+    this.$isProcessing = data.is_processing;
+    this.$onlyWhenOnline = data.only_when_online;
+    this.$cron = data.cron;
+    this.$updatedAt = new Date(data.updated_at);
+  };
+  delete = async () => this.client.schedules.control(this.id).delete();
+  execute = async () => this.client.schedules.control(this.id).execute();
+};
+var ServerScheduleTask = class {
+  client;
+  scheduleId;
+  $action;
+  get action() {
+    return this.$action;
   }
+  $continueOnFailure;
+  get continueOnFailure() {
+    return this.$continueOnFailure;
+  }
+  createdAt;
+  id;
+  $isQueued;
+  get isQueued() {
+    return this.$isQueued;
+  }
+  $payload;
+  get payload() {
+    return this.$payload;
+  }
+  $sequenceId;
+  get sequenceId() {
+    return this.$sequenceId;
+  }
+  $timeOffset;
+  get timeOffset() {
+    return this.$timeOffset;
+  }
+  $updatedAt;
+  get updatedAt() {
+    return this.$updatedAt;
+  }
+  constructor(client, scheduleId, task) {
+    this.client = client;
+    this.scheduleId = scheduleId;
+    this.$action = task.action;
+    this.$continueOnFailure = task.continue_on_failure;
+    this.createdAt = new Date(task.created_at);
+    this.id = task.id;
+    this.$isQueued = task.is_queued;
+    this.$payload = task.payload;
+    this.$sequenceId = task.sequence_id;
+    this.$timeOffset = task.time_offset;
+    this.$updatedAt = task.updated_at ? new Date(task.updated_at) : null;
+  }
+  delete = async () => this.client.schedules.control(this.scheduleId).tasks.delete(this.id);
+  update = async (opts) => {
+    const data = await this.client.schedules.control(this.scheduleId).tasks.update(this.id, opts);
+    this.$action = data.action;
+    this.$continueOnFailure = data.continue_on_failure;
+    this.$isQueued = data.is_queued;
+    this.$payload = data.payload;
+    this.$sequenceId = data.sequence_id;
+    this.$timeOffset = data.time_offset;
+    this.$updatedAt = data.updated_at ? new Date(data.updated_at) : null;
+  };
+};
+
+// src/humane/ServerUser.ts
+var ServerUser = class {
+  client;
+  uuid;
+  username;
+  email;
+  language;
+  image;
+  admin;
+  root_admin;
+  has2faEnabled;
+  createdAt;
+  $permissions;
+  get permissions() {
+    return this.$permissions;
+  }
+  constructor(client, user) {
+    this.client = client;
+    this.uuid = user.uuid;
+    this.username = user.username;
+    this.email = user.email;
+    this.language = user.language;
+    this.image = user.image;
+    this.admin = user.admin;
+    this.root_admin = user.root_admin;
+    this.has2faEnabled = user["2fa_enabled"];
+    this.createdAt = new Date(user.created_at);
+    this.$permissions = user.permissions;
+  }
+  update = async (permissions) => {
+    const data = await this.client.users.update(this.uuid, permissions);
+    this.$permissions = data.permissions;
+  };
+  delete = async () => this.client.users.delete(this.uuid);
+};
+
+// src/humane/Server.ts
+var Server = class {
+  client;
+  ownsServer;
+  identifier;
+  internalId;
+  uuid;
+  $name;
+  get name() {
+    return this.$name;
+  }
+  node;
+  isNodeUnderMaintenance;
+  sftp;
+  $description;
+  get description() {
+    return this.$description;
+  }
+  limits;
+  invocation;
+  $dockerImage;
+  get dockerImage() {
+    return this.$dockerImage;
+  }
+  eggFeatures;
+  featureLimits;
+  status;
+  isSuspended;
+  isInstalling;
+  isTransferring;
+  allocations;
+  variables;
+  egg;
+  subusers;
+  constructor(client, server) {
+    this.client = client;
+    this.ownsServer = server.server_owner;
+    this.identifier = server.identifier;
+    this.internalId = server.internal_id;
+    this.uuid = server.uuid;
+    this.$name = server.name;
+    this.node = server.node;
+    this.isNodeUnderMaintenance = server.is_node_under_maintenance;
+    this.sftp = server.sftp_details;
+    this.$description = server.description;
+    this.limits = server.limits;
+    this.invocation = server.invocation;
+    this.$dockerImage = server.docker_image;
+    this.eggFeatures = server.egg_features;
+    this.featureLimits = server.feature_limits;
+    this.status = server.status;
+    this.isSuspended = server.is_suspended;
+    this.isInstalling = server.is_installing;
+    this.isTransferring = server.is_transferring;
+    this.allocations = server.relationships.allocations.data.map(
+      (d) => new ServerAllocation(this.client, d.attributes)
+    );
+    this.variables = server.relationships.variables.data.map(
+      (d) => d.attributes
+    );
+    this.egg = server.relationships.egg?.attributes;
+    this.subusers = server.relationships.subusers?.data.map(
+      (d) => new ServerUser(this.client, d.attributes)
+    );
+  }
+  rename = async (name) => {
+    await this.client.settings.rename(name);
+    this.$name = name;
+  };
+  updateDescription = async (description) => {
+    await this.client.settings.updateDescription(description);
+    this.$description = description;
+  };
+  reinstall = async () => this.client.settings.reinstall();
+  changeDockerImage = async (image) => {
+    await this.client.settings.changeDockerImage(image);
+    this.$dockerImage = image;
+  };
+  getActivityLogs = async (opts = { page: 1, per_page: 50 }) => this.client.activity.list(opts.page, opts.per_page);
+  websocket = (stripColors = false) => this.client.websocket(stripColors);
+  getServerStats = async () => this.client.resources();
+  runCommand = async (command) => this.client.command(command);
+  sendPowerSignal = async (signal) => this.client.power(signal);
+  getDatabases = async (opts = {
+    include: [],
+    page: 1
+  }) => {
+    const data = await this.client.databases.list(opts.include, opts.page);
+    return data.map((d) => new ServerDatabase(this.client, d));
+  };
+  createDatabase = async (database, remote) => {
+    const data = await this.client.databases.create(database, remote);
+    return new ServerDatabase(this.client, data);
+  };
+  getSchedules = async () => {
+    const data = await this.client.schedules.list();
+    return data.map((d) => new ServerSchedule(this.client, d));
+  };
+  createSchedule = async (...opts) => {
+    const data = await this.client.schedules.create(...opts);
+    return new ServerSchedule(this.client, data);
+  };
+  getBackups = async (page = 1) => {
+    const data = await this.client.backups.list(page);
+    return data.map((d) => new ServerBackup(this.client, d));
+  };
+  createBackup = async (...args) => {
+    const data = await this.client.backups.create(...args);
+    return new ServerBackup(this.client, data);
+  };
+  getAllocations = async () => {
+    const data = await this.client.allocations.list();
+    return data.map((d) => new ServerAllocation(this.client, d));
+  };
+  createAllocation = async () => {
+    const data = await this.client.allocations.autoAssign();
+    return new ServerAllocation(this.client, data);
+  };
+  getFiles = async (path2) => {
+    const data = await this.client.files.list(path2);
+    return data.map((d) => new ServerFile(this.client, d));
+  };
+  createFolder = async (...opts) => this.client.files.createFolder(...opts);
+  uploadFile = async (...opts) => this.client.files.upload(...opts);
+  uploadFileGetUrl = async (...opts) => this.client.files.uploadGetUrl(...opts);
+  pullFileFromRemote = async (...opts) => this.client.files.pullFromRemote(...opts);
+  getUsers = async () => {
+    const data = await this.client.users.list();
+    return data.map((d) => new ServerUser(this.client, d));
+  };
+  createUser = async (email, permissions) => {
+    const data = await this.client.users.create(email, permissions);
+    return new ServerUser(this.client, data);
+  };
+  getStartupInfo = async () => this.client.startup.list();
+  setStartupVariable = async (key, value) => this.client.startup.set(key, value);
+};
+
+// src/humane/Client.ts
+var Client3 = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get $client() {
+    return this.client;
+  }
+  getAccount = async () => {
+    const user = await this.client.account.info();
+    return new Account2(this.client, user);
+  };
+  listPermissions = async () => this.client.listPermissions();
+  listServers = async (opts = { type: "accessible", page: 1, per_page: 50 }) => {
+    const data = await this.client.listServers(
+      opts.type,
+      opts.page,
+      opts.per_page,
+      opts.include
+    );
+    return data.map((d) => new Server(this.client.server(d.uuid), d));
+  };
+  getServer = async (uuid, include) => {
+    const server = await this.client.server(uuid).info(include);
+    return new Server(this.client.server(uuid), server);
+  };
+};
+
+// src/index.ts
+var createPelicanClient = (url, token, suffix = "/api") => {
+  const client = new PelicanAPIClient(url, token, suffix);
+  return new Client3(client);
 };
 export {
-  PelicanApplication,
-  PelicanClient
+  Account2 as Account,
+  Client3 as Client,
+  Server,
+  ServerAllocation,
+  ServerBackup,
+  ServerDatabase,
+  ServerFile,
+  ServerSchedule,
+  ServerUser,
+  createPelicanClient
 };
 /*
  * @author BothimTV