@ebowwa/hetzner 0.3.2 → 0.3.3

package/dist/servers.js

@@ -0,0 +1,688 @@
+// @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/servers.ts
+import { z as z2 } from "zod";
+class ServerOperations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const response = await this.client.request("/servers");
+    const validated = HetznerListServersResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner list servers validation warning:", validated.error.issues);
+      return response.servers;
+    }
+    return validated.data.servers;
+  }
+  async get(id) {
+    const response = await this.client.request(`/servers/${id}`);
+    const validated = HetznerGetServerResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner get server validation warning:", validated.error.issues);
+      return response.server;
+    }
+    return validated.data.server;
+  }
+  async create(options) {
+    const createServerOptionsSchema = z2.object({
+      name: z2.string().min(1),
+      server_type: z2.string().min(1).default("cpx11"),
+      image: z2.string().min(1).default("ubuntu-24.04"),
+      location: z2.string().min(1).optional(),
+      datacenter: z2.string().min(1).optional(),
+      ssh_keys: z2.array(z2.union([z2.string(), z2.number()])).default([]),
+      volumes: z2.array(z2.number()).default([]),
+      labels: z2.record(z2.string(), z2.any()).optional(),
+      start_after_create: z2.boolean().default(true),
+      user_data: z2.string().optional()
+    });
+    const validatedOptions = createServerOptionsSchema.safeParse(options);
+    if (!validatedOptions.success) {
+      throw new Error(`Invalid server options: ${validatedOptions.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    if (validatedOptions.data.location && validatedOptions.data.datacenter) {
+      throw new Error("Cannot specify both location and datacenter");
+    }
+    const body = {
+      name: validatedOptions.data.name,
+      server_type: validatedOptions.data.server_type,
+      image: validatedOptions.data.image,
+      ...validatedOptions.data.location && { location: validatedOptions.data.location },
+      ...validatedOptions.data.datacenter && { datacenter: { id: validatedOptions.data.datacenter } },
+      ssh_keys: validatedOptions.data.ssh_keys,
+      volumes: validatedOptions.data.volumes,
+      ...validatedOptions.data.labels && { labels: validatedOptions.data.labels },
+      start_after_create: validatedOptions.data.start_after_create,
+      ...validatedOptions.data.user_data && { user_data: validatedOptions.data.user_data }
+    };
+    console.log("[Hetzner] Creating server with body:", JSON.stringify(body, null, 2));
+    const response = await this.client.request("/servers", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const validatedResponse = HetznerCreateServerResponseSchema.safeParse(response);
+    if (!validatedResponse.success) {
+      console.warn("Hetzner create server validation warning:", validatedResponse.error.issues);
+      return response;
+    }
+    return validatedResponse.data;
+  }
+  async createAndWait(options, onProgress) {
+    const response = await this.create(options);
+    const waitOptions = onProgress !== undefined ? { onProgress } : {};
+    if (response.action.status === "running") {
+      await this.client.actions.waitFor(response.action.id, waitOptions);
+    }
+    if (response.next_actions.length > 0) {
+      for (const action of response.next_actions) {
+        await this.client.actions.waitFor(action.id, waitOptions);
+      }
+    }
+    const server = await this.get(response.server.id);
+    return server;
+  }
+  async delete(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}`, { method: "DELETE" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner delete server validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async deleteAndWait(id, onProgress) {
+    const action = await this.delete(id);
+    await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async powerOn(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/poweron`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner power on validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async powerOnAndWait(id, onProgress) {
+    const action = await this.powerOn(id);
+    return await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async powerOff(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/poweroff`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner power off validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async powerOffAndWait(id, onProgress) {
+    const action = await this.powerOff(id);
+    return await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async reboot(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/reboot`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner reboot validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async rebootAndWait(id, onProgress) {
+    const action = await this.reboot(id);
+    return await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async shutdown(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/shutdown`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner shutdown validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async shutdownAndWait(id, onProgress) {
+    const action = await this.shutdown(id);
+    return await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async reset(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/reset`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner reset validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async resetAndWait(id, onProgress) {
+    const action = await this.reset(id);
+    return await this.client.actions.waitFor(action.id, { onProgress });
+  }
+  async rebuild(id, image) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/rebuild`, {
+      method: "POST",
+      body: JSON.stringify({ image })
+    });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner rebuild validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async enableRescue(id, options) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/enable_rescue`, {
+      method: "POST",
+      body: JSON.stringify(options || {})
+    });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner enable rescue validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async disableRescue(id) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/disable_rescue`, { method: "POST" });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner disable rescue validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async changeType(id, serverType, upgradeDisk = false) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const response = await this.client.request(`/servers/${validatedId.data}/actions/change_type`, {
+      method: "POST",
+      body: JSON.stringify({ server_type: serverType, upgrade_disk: upgradeDisk })
+    });
+    const validated = HetznerActionSchema.safeParse(response.action);
+    if (!validated.success) {
+      console.warn("Hetzner change type validation warning:", validated.error.issues);
+      return response.action;
+    }
+    return validated.data;
+  }
+  async getActions(id, options) {
+    const serverIdSchema = z2.number().int().positive();
+    const validatedId = serverIdSchema.safeParse(id);
+    if (!validatedId.success) {
+      throw new Error(`Invalid server ID: ${validatedId.error.issues.map((i) => i.message).join(", ")}`);
+    }
+    const params = new URLSearchParams;
+    if (options?.status)
+      params.append("status", options.status);
+    if (options?.sort)
+      params.append("sort", options.sort);
+    const query = params.toString();
+    const response = await this.client.request(`/servers/${validatedId.data}/actions${query ? `?${query}` : ""}`);
+    return response.actions;
+  }
+}
+export {
+  ServerOperations
+};