@ebowwa/hetzner 0.3.1 → 0.3.3

package/dist/ssh-keys.js

@@ -0,0 +1,474 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/schemas.ts
+import { z } from "zod";
+import {
+  EnvironmentStatus,
+  ActionStatus,
+  VolumeStatus
+} from "@ebowwa/codespaces-types/compile";
+var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var ipv6Regex = /^[0-9a-fA-F:]+(?:\/\d{1,3})?$/;
+var ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+var HetznerErrorSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  details: z.any().optional()
+});
+var HetznerPaginationSchema = z.object({
+  page: z.number(),
+  per_page: z.number(),
+  previous_page: z.number().nullable(),
+  next_page: z.number().nullable(),
+  last_page: z.number(),
+  total_entries: z.number()
+});
+var HetznerMetaSchema = z.object({
+  pagination: HetznerPaginationSchema.optional()
+});
+var HetznerActionResourceSchema = z.object({
+  id: z.number(),
+  type: z.enum([
+    "server",
+    "volume",
+    "network",
+    "floating_ip",
+    "load_balancer",
+    "certificate",
+    "firewall",
+    "image"
+  ])
+});
+var HetznerActionErrorSchema = z.object({
+  code: z.string(),
+  message: z.string()
+});
+var HetznerActionSchema = z.object({
+  id: z.number(),
+  command: z.string(),
+  status: z.nativeEnum(ActionStatus),
+  started: z.string(),
+  finished: z.string().nullable(),
+  progress: z.number().min(0).max(100),
+  resources: z.array(HetznerActionResourceSchema),
+  error: HetznerActionErrorSchema.nullable()
+});
+var HetznerActionResponseSchema = z.object({
+  action: HetznerActionSchema
+});
+var HetznerActionsResponseSchema = z.object({
+  actions: z.array(HetznerActionSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerServerImageSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  type: z.enum(["snapshot", "backup", "system"])
+});
+var HetznerIPv4Schema = z.object({
+  ip: z.string().regex(ipv4Regex),
+  blocked: z.boolean()
+});
+var HetznerIPv6Schema = z.object({
+  ip: z.string().regex(ipv6Regex),
+  blocked: z.boolean()
+});
+var HetznerFloatingIpRefSchema = z.object({
+  id: z.number(),
+  ip: z.string()
+});
+var HetznerFirewallRefSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  status: z.enum(["applied", "pending"])
+});
+var HetznerPublicNetSchema = z.object({
+  ipv4: HetznerIPv4Schema,
+  ipv6: HetznerIPv6Schema.optional(),
+  floating_ips: z.array(HetznerFloatingIpRefSchema),
+  firewalls: z.array(HetznerFirewallRefSchema)
+});
+var HetznerServerTypeSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  cores: z.number(),
+  memory: z.number(),
+  disk: z.number()
+});
+var HetznerLocationSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  country: z.string(),
+  city: z.string(),
+  latitude: z.number(),
+  longitude: z.number(),
+  network_zone: z.string()
+});
+var HetznerDatacenterSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  location: HetznerLocationSchema,
+  supported_server_types: z.array(z.object({
+    id: z.number(),
+    name: z.string()
+  })).optional().nullable()
+});
+var HetznerVolumeRefSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  size: z.number().positive(),
+  linux_device: z.string()
+});
+var HetznerServerProtectionSchema = z.object({
+  delete: z.boolean(),
+  rebuild: z.boolean()
+});
+var HetznerServerSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1),
+  status: z.nativeEnum(EnvironmentStatus),
+  image: HetznerServerImageSchema.nullable().optional(),
+  public_net: HetznerPublicNetSchema,
+  server_type: HetznerServerTypeSchema,
+  datacenter: HetznerDatacenterSchema,
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime(),
+  protection: HetznerServerProtectionSchema,
+  volumes: z.array(HetznerVolumeRefSchema)
+});
+var HetznerListServersResponseSchema = z.object({
+  servers: z.array(HetznerServerSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetServerResponseSchema = z.object({
+  server: HetznerServerSchema
+});
+var HetznerCreateServerRequestSchema = z.object({
+  name: z.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  server_type: z.string().min(1),
+  image: z.string().min(1),
+  location: z.string().min(1).optional(),
+  datacenter: z.string().min(1).optional(),
+  ssh_keys: z.array(z.union([z.string(), z.number()])).optional(),
+  volumes: z.array(z.number().positive()).optional(),
+  labels: z.record(z.string(), z.any()).optional(),
+  start_after_create: z.boolean().optional()
+}).refine((data) => !(data.location && data.datacenter), "Cannot specify both location and datacenter");
+var HetznerCreateServerResponseSchema = z.object({
+  server: HetznerServerSchema,
+  action: HetznerActionSchema,
+  next_actions: z.array(HetznerActionSchema),
+  root_password: z.string().nullable()
+});
+var HetznerUpdateServerRequestSchema = z.object({
+  name: z.string().min(1).max(64).optional(),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var HetznerUpdateServerResponseSchema = z.object({
+  server: HetznerServerSchema
+});
+var HetznerVolumeLocationSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  country: z.string(),
+  city: z.string(),
+  latitude: z.number(),
+  longitude: z.number()
+});
+var HetznerVolumeProtectionSchema = z.object({
+  delete: z.boolean()
+});
+var HetznerVolumeSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1),
+  status: z.nativeEnum(VolumeStatus),
+  server: z.number().positive().nullable().optional(),
+  size: z.number().positive(),
+  linux_device: z.string().nullable().optional(),
+  format: z.string().nullable().optional(),
+  location: HetznerVolumeLocationSchema.nullable().optional(),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime(),
+  protection: HetznerVolumeProtectionSchema
+});
+var HetznerListVolumesResponseSchema = z.object({
+  volumes: z.array(HetznerVolumeSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetVolumeResponseSchema = z.object({
+  volume: HetznerVolumeSchema
+});
+var HetznerCreateVolumeRequestSchema = z.object({
+  name: z.string().min(1).max(64),
+  size: z.number().positive().multipleOf(1),
+  server: z.number().positive().optional(),
+  location: z.string().min(1).optional(),
+  automount: z.boolean().optional(),
+  format: z.string().optional(),
+  labels: z.record(z.string(), z.any()).optional()
+}).refine((data) => {
+  return Number.isInteger(data.size);
+}, "Volume size must be a whole number in GB");
+var HetznerCreateVolumeResponseSchema = z.object({
+  volume: HetznerVolumeSchema,
+  action: HetznerActionSchema,
+  next_actions: z.array(HetznerActionSchema)
+});
+var HetznerSubnetSchema = z.object({
+  type: z.enum(["server", "cloud", "vswitch"]),
+  ip_range: z.string().regex(ipRegex),
+  network_zone: z.string(),
+  gateway: z.string().regex(ipRegex)
+});
+var HetznerRouteSchema = z.object({
+  destination: z.string().regex(ipRegex),
+  gateway: z.string().regex(ipRegex)
+});
+var HetznerNetworkProtectionSchema = z.object({
+  delete: z.boolean()
+});
+var HetznerNetworkSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  ip_range: z.string().regex(ipRegex),
+  subnets: z.array(HetznerSubnetSchema),
+  routes: z.array(HetznerRouteSchema),
+  servers: z.array(z.number().positive()),
+  protection: HetznerNetworkProtectionSchema,
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListNetworksResponseSchema = z.object({
+  networks: z.array(HetznerNetworkSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetNetworkResponseSchema = z.object({
+  network: HetznerNetworkSchema
+});
+var HetznerSSHKeySchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  fingerprint: z.string(),
+  public_key: z.string(),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListSSHKeysResponseSchema = z.object({
+  ssh_keys: z.array(HetznerSSHKeySchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetSSHKeyResponseSchema = z.object({
+  ssh_key: HetznerSSHKeySchema
+});
+var HetznerCreateSSHKeyRequestSchema = z.object({
+  name: z.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  public_key: z.string().min(1),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var HetznerCreateSSHKeyResponseSchema = z.object({
+  ssh_key: HetznerSSHKeySchema
+});
+var HetznerFloatingIpSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  description: z.string().optional(),
+  type: z.enum(["ipv4", "ipv6"]),
+  ip: z.string().regex(ipRegex),
+  server: z.number().positive().nullable(),
+  dns_ptr: z.array(z.object({
+    ip: z.string(),
+    dns_ptr: z.string()
+  })),
+  home_location: HetznerLocationSchema,
+  blocked: z.boolean(),
+  protection: z.object({
+    delete: z.boolean()
+  }),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListFloatingIpsResponseSchema = z.object({
+  floating_ips: z.array(HetznerFloatingIpSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerFirewallRuleSchema = z.object({
+  direction: z.enum(["in", "out"]),
+  source_ips: z.array(z.string().regex(ipRegex)).optional(),
+  destination_ips: z.array(z.string().regex(ipRegex)).optional(),
+  source_port: z.string().optional(),
+  destination_port: z.string().optional(),
+  protocol: z.enum(["tcp", "udp", "icmp", "esp", "gre"])
+});
+var HetznerFirewallResourceSchema = z.object({
+  type: z.enum(["server", "label_selector"]),
+  server: z.object({
+    id: z.number().positive()
+  }).optional(),
+  label_selector: z.object({
+    selector: z.string()
+  }).optional()
+});
+var HetznerFirewallSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  rules: z.array(HetznerFirewallRuleSchema),
+  apply_to: z.array(HetznerFirewallResourceSchema),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListFirewallsResponseSchema = z.object({
+  firewalls: z.array(HetznerFirewallSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerIsoSchema = z.object({
+  id: z.number().positive(),
+  name: z.string(),
+  description: z.string(),
+  type: z.enum(["public", "private"]),
+  deprecated: z.date().nullable().optional(),
+  architecture: z.array(z.enum(["x86", "arm"])).optional()
+});
+var HetznerListIsosResponseSchema = z.object({
+  isos: z.array(HetznerIsoSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerListLocationsResponseSchema = z.object({
+  locations: z.array(HetznerLocationSchema)
+});
+var HetznerListDatacentersResponseSchema = z.object({
+  datacenters: z.array(HetznerDatacenterSchema)
+});
+var HetznerServerTypePricingSchema = z.object({
+  location: z.string().nullable().optional(),
+  price_hourly: z.object({
+    net: z.string(),
+    gross: z.string()
+  }),
+  price_monthly: z.object({
+    net: z.string(),
+    gross: z.string()
+  })
+});
+var HetznerServerTypeExtendedSchema = HetznerServerTypeSchema.extend({
+  deprecated: z.boolean().optional(),
+  prices: z.array(HetznerServerTypePricingSchema),
+  storage_type: z.enum(["local", "network"]),
+  cpu_type: z.enum(["shared", "dedicated"])
+});
+var HetznerListServerTypesResponseSchema = z.object({
+  server_types: z.array(HetznerServerTypeExtendedSchema)
+});
+var HetznerCertificateSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  labels: z.record(z.string(), z.any()),
+  certificate: z.string(),
+  not_valid_before: z.string().datetime(),
+  not_valid_after: z.string().datetime(),
+  domain_names: z.array(z.string().url()),
+  fingerprint: z.string(),
+  created: z.string().datetime(),
+  status: z.enum(["pending", "issued", "failed", "revoked"]),
+  failed: z.boolean().optional(),
+  type: z.enum(["uploaded", "managed"]),
+  usage: z.array(z.enum(["dual_stack", "server", "load_balancer", "dns"])).optional()
+});
+var HetznerListCertificatesResponseSchema = z.object({
+  certificates: z.array(HetznerCertificateSchema),
+  meta: HetznerMetaSchema
+});
+function createPaginatedResponseSchema(itemSchema, itemName) {
+  return z.object({
+    [itemName]: z.array(itemSchema),
+    meta: HetznerMetaSchema
+  });
+}
+function createItemResponseSchema(itemSchema, itemName) {
+  return z.object({
+    [itemName]: itemSchema
+  });
+}
+
+// src/ssh-keys.ts
+class SSHKeyOperations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.request("/ssh_keys");
+    const validated = HetznerListSSHKeysResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner list SSH keys validation warning:", validated.error.issues);
+      return response.ssh_keys;
+    }
+    return validated.data.ssh_keys;
+  }
+  async get(idOrName) {
+    const endpoint = typeof idOrName === "number" ? `/ssh_keys/${idOrName}` : `/ssh_keys?name=${encodeURIComponent(idOrName)}`;
+    const response = await this.client.request(endpoint);
+    const validated = HetznerGetSSHKeyResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner get SSH key validation warning:", validated.error.issues);
+      return response.ssh_key;
+    }
+    return validated.data.ssh_key;
+  }
+  async create(options) {
+    const validatedOptions = HetznerCreateSSHKeyRequestSchema.safeParse(options);
+    if (!validatedOptions.success) {
+      throw new Error(`Invalid SSH key options: ${validatedOptions.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const body = {
+      name: validatedOptions.data.name,
+      public_key: validatedOptions.data.public_key,
+      ...validatedOptions.data.labels && { labels: validatedOptions.data.labels }
+    };
+    const response = await this.client.request("/ssh_keys", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const validated = HetznerCreateSSHKeyResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner create SSH key validation warning:", validated.error.issues);
+      return response.ssh_key;
+    }
+    return validated.data.ssh_key;
+  }
+  async delete(id) {
+    await this.client.request(`/ssh_keys/${id}`, { method: "DELETE" });
+  }
+  async findByName(name) {
+    try {
+      const keys = await this.list();
+      return keys.find((key) => key.name === name);
+    } catch {
+      return;
+    }
+  }
+}
+export {
+  SSHKeyOperations
+};

package/dist/types.js

@@ -0,0 +1,101 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/types.ts
+import {
+  EnvironmentStatus,
+  ActionStatus,
+  VolumeStatus
+} from "@ebowwa/codespaces-types/compile";
+var ActionCommand;
+((ActionCommand2) => {
+  ActionCommand2["CreateServer"] = "create_server";
+  ActionCommand2["DeleteServer"] = "delete_server";
+  ActionCommand2["StartServer"] = "start_server";
+  ActionCommand2["StopServer"] = "stop_server";
+  ActionCommand2["RebootServer"] = "reboot_server";
+  ActionCommand2["ResetServer"] = "reset_server";
+  ActionCommand2["ShutdownServer"] = "shutdown_server";
+  ActionCommand2["Poweroff"] = "poweroff";
+  ActionCommand2["ChangeServerType"] = "change_server_type";
+  ActionCommand2["RebuildServer"] = "rebuild_server";
+  ActionCommand2["EnableBackup"] = "enable_backup";
+  ActionCommand2["DisableBackup"] = "disable_backup";
+  ActionCommand2["CreateImage"] = "create_image";
+  ActionCommand2["ChangeDnsPtr"] = "change_dns_ptr";
+  ActionCommand2["AttachToNetwork"] = "attach_to_network";
+  ActionCommand2["DetachFromNetwork"] = "detach_from_network";
+  ActionCommand2["ChangeAliasIps"] = "change_alias_ips";
+  ActionCommand2["EnableRescue"] = "enable_rescue";
+  ActionCommand2["DisableRescue"] = "disable_rescue";
+  ActionCommand2["ChangeProtection"] = "change_protection";
+  ActionCommand2["CreateVolume"] = "create_volume";
+  ActionCommand2["DeleteVolume"] = "delete_volume";
+  ActionCommand2["AttachVolume"] = "attach_volume";
+  ActionCommand2["DetachVolume"] = "detach_volume";
+  ActionCommand2["ResizeVolume"] = "resize_volume";
+  ActionCommand2["VolumeChangeProtection"] = "volume_change_protection";
+  ActionCommand2["AddSubnet"] = "add_subnet";
+  ActionCommand2["DeleteSubnet"] = "delete_subnet";
+  ActionCommand2["AddRoute"] = "add_route";
+  ActionCommand2["DeleteRoute"] = "delete_route";
+  ActionCommand2["ChangeIpRange"] = "change_ip_range";
+  ActionCommand2["NetworkChangeProtection"] = "network_change_protection";
+  ActionCommand2["AssignFloatingIp"] = "assign_floating_ip";
+  ActionCommand2["UnassignFloatingIp"] = "unassign_floating_ip";
+  ActionCommand2["FloatingIpChangeDnsPtr"] = "floating_ip_change_dns_ptr";
+  ActionCommand2["FloatingIpChangeProtection"] = "floating_ip_change_protection";
+  ActionCommand2["CreateLoadBalancer"] = "create_load_balancer";
+  ActionCommand2["DeleteLoadBalancer"] = "delete_load_balancer";
+  ActionCommand2["AddTarget"] = "add_target";
+  ActionCommand2["RemoveTarget"] = "remove_target";
+  ActionCommand2["AddService"] = "add_service";
+  ActionCommand2["UpdateService"] = "update_service";
+  ActionCommand2["DeleteService"] = "delete_service";
+  ActionCommand2["LoadBalancerAttachToNetwork"] = "load_balancer_attach_to_network";
+  ActionCommand2["LoadBalancerDetachFromNetwork"] = "load_balancer_detach_from_network";
+  ActionCommand2["ChangeAlgorithm"] = "change_algorithm";
+  ActionCommand2["ChangeType"] = "change_type";
+  ActionCommand2["LoadBalancerChangeProtection"] = "load_balancer_change_protection";
+  ActionCommand2["IssueCertificate"] = "issue_certificate";
+  ActionCommand2["RetryCertificate"] = "retry_certificate";
+  ActionCommand2["SetFirewallRules"] = "set_firewall_rules";
+  ActionCommand2["ApplyFirewall"] = "apply_firewall";
+  ActionCommand2["RemoveFirewall"] = "remove_firewall";
+  ActionCommand2["FirewallChangeProtection"] = "firewall_change_protection";
+  ActionCommand2["ImageChangeProtection"] = "image_change_protection";
+})(ActionCommand ||= {});
+var ResourceType;
+((ResourceType2) => {
+  ResourceType2["Server"] = "server";
+  ResourceType2["Volume"] = "volume";
+  ResourceType2["Network"] = "network";
+  ResourceType2["FloatingIp"] = "floating_ip";
+  ResourceType2["LoadBalancer"] = "load_balancer";
+  ResourceType2["Certificate"] = "certificate";
+  ResourceType2["Firewall"] = "firewall";
+  ResourceType2["Image"] = "image";
+})(ResourceType ||= {});
+export {
+  VolumeStatus,
+  ResourceType,
+  EnvironmentStatus,
+  ActionStatus,
+  ActionCommand
+};

package/dist/volumes.js

@@ -0,0 +1,119 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/volumes.ts
+class VolumeOperations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    const params = new URLSearchParams;
+    if (options?.name)
+      params.set("name", options.name);
+    if (options?.status)
+      params.set("status", options.status);
+    if (options?.sort)
+      params.set("sort", options.sort);
+    if (options?.label_selector)
+      params.set("label_selector", options.label_selector);
+    const endpoint = `/volumes${params.toString() ? `?${params}` : ""}`;
+    const response = await this.client.request(endpoint);
+    return response.volumes || [];
+  }
+  async get(id) {
+    const response = await this.client.request(`/volumes/${id}`);
+    return response.volume;
+  }
+  async create(options) {
+    const response = await this.client.request("/volumes", {
+      method: "POST",
+      body: JSON.stringify({
+        name: options.name,
+        size: options.size,
+        server: options.server,
+        location: options.location,
+        automount: options.automount ?? true,
+        format: options.format,
+        labels: options.labels
+      })
+    });
+    return response;
+  }
+  async delete(id) {
+    const response = await this.client.request(`/volumes/${id}`, {
+      method: "DELETE"
+    });
+    return response.action;
+  }
+  async attach(volumeId, serverId, automount = true) {
+    const response = await this.client.request(`/volumes/${volumeId}/actions/attach`, {
+      method: "POST",
+      body: JSON.stringify({
+        server: serverId,
+        automount
+      })
+    });
+    return response.action;
+  }
+  async detach(volumeId) {
+    const response = await this.client.request(`/volumes/${volumeId}/actions/detach`, {
+      method: "POST"
+    });
+    return response.action;
+  }
+  async resize(volumeId, size) {
+    const response = await this.client.request(`/volumes/${volumeId}/actions/resize`, {
+      method: "POST",
+      body: JSON.stringify({ size })
+    });
+    return response.action;
+  }
+  async changeProtection(volumeId, deleteProtection) {
+    const response = await this.client.request(`/volumes/${volumeId}/actions/change_protection`, {
+      method: "POST",
+      body: JSON.stringify({
+        delete: deleteProtection
+      })
+    });
+    return response.action;
+  }
+  async updateLabels(volumeId, labels) {
+    const response = await this.client.request(`/volumes/${volumeId}`, {
+      method: "PUT",
+      body: JSON.stringify({ labels })
+    });
+    return response.volume;
+  }
+  static calculatePrice(sizeInGB) {
+    const PRICE_PER_GB_MONTHLY = 0.008;
+    const HOURS_PER_MONTH = 730;
+    const monthly = sizeInGB * PRICE_PER_GB_MONTHLY;
+    const hourly = monthly / HOURS_PER_MONTH;
+    return {
+      size: sizeInGB,
+      monthly: Math.round(monthly * 100) / 100,
+      hourly: Math.round(hourly * 1e4) / 1e4,
+      currency: "EUR"
+    };
+  }
+}
+export {
+  VolumeOperations
+};