latitudesh-typescript-sdk 0.6.3 → 0.7.0

package/bin/mcp-server.js

@@ -53149,9 +53149,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2023-06-01",
-    sdkVersion: "0.6.3",
-    genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 0.6.3 2.914.0 2023-06-01 latitudesh-typescript-sdk"
+    sdkVersion: "0.6.4",
+    genVersion: "2.915.0",
+    userAgent: "speakeasy-sdk/typescript 0.6.4 2.915.0 2023-06-01 latitudesh-typescript-sdk"
   };
 });
 
@@ -55362,14 +55362,14 @@ var init_customtagdata = __esm(() => {
   CustomTagDataAttributes$inboundSchema = objectType({
     name: stringType().optional(),
     slug: stringType().optional(),
-    description: stringType().optional(),
+    description: nullableType(stringType()).optional(),
     color: stringType().optional(),
     team: TeamInclude$inboundSchema.optional()
   });
   CustomTagDataAttributes$outboundSchema = objectType({
     name: stringType().optional(),
     slug: stringType().optional(),
-    description: stringType().optional(),
+    description: nullableType(stringType()).optional(),
     color: stringType().optional(),
     team: TeamInclude$outboundSchema.optional()
   });
@@ -56962,6 +56962,104 @@ var init_kubernetesclusterupdateresponse = __esm(() => {
   });
 });
 
+// src/models/manageddatabaseplanattributes.ts
+var ManagedDatabasePlanAttributesType, ManagedDatabasePlanAttributesType$inboundSchema, ManagedDatabasePlanAttributesType$outboundSchema, ManagedDatabasePlanAttributesSpecs$inboundSchema, ManagedDatabasePlanAttributesSpecs$outboundSchema, ManagedDatabasePlanAttributesSite$inboundSchema, ManagedDatabasePlanAttributesSite$outboundSchema, ManagedDatabasePlanAttributesPricing$inboundSchema, ManagedDatabasePlanAttributesPricing$outboundSchema, ManagedDatabasePlanAttributesRegion$inboundSchema, ManagedDatabasePlanAttributesRegion$outboundSchema, ManagedDatabasePlanAttributesAttributes$inboundSchema, ManagedDatabasePlanAttributesAttributes$outboundSchema, ManagedDatabasePlanAttributes$inboundSchema, ManagedDatabasePlanAttributes$outboundSchema;
+var init_manageddatabaseplanattributes = __esm(() => {
+  init_v3();
+  ManagedDatabasePlanAttributesType = {
+    ManagedDatabasePlans: "managed_database_plans"
+  };
+  ManagedDatabasePlanAttributesType$inboundSchema = nativeEnumType(ManagedDatabasePlanAttributesType);
+  ManagedDatabasePlanAttributesType$outboundSchema = ManagedDatabasePlanAttributesType$inboundSchema;
+  ManagedDatabasePlanAttributesSpecs$inboundSchema = objectType({
+    cpu: stringType().optional(),
+    memory: stringType().optional(),
+    storage: stringType().optional(),
+    shards: numberType().int().optional(),
+    replicas: numberType().int().optional(),
+    iops: nullableType(stringType()).optional()
+  });
+  ManagedDatabasePlanAttributesSpecs$outboundSchema = objectType({
+    cpu: stringType().optional(),
+    memory: stringType().optional(),
+    storage: stringType().optional(),
+    shards: numberType().int().optional(),
+    replicas: numberType().int().optional(),
+    iops: nullableType(stringType()).optional()
+  });
+  ManagedDatabasePlanAttributesSite$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional(),
+    facility: stringType().optional()
+  });
+  ManagedDatabasePlanAttributesSite$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional(),
+    facility: stringType().optional()
+  });
+  ManagedDatabasePlanAttributesPricing$inboundSchema = objectType({
+    month: nullableType(numberType()).optional(),
+    year: nullableType(numberType()).optional()
+  });
+  ManagedDatabasePlanAttributesPricing$outboundSchema = objectType({
+    month: nullableType(numberType()).optional(),
+    year: nullableType(numberType()).optional()
+  });
+  ManagedDatabasePlanAttributesRegion$inboundSchema = objectType({
+    region: stringType().optional(),
+    city: stringType().optional(),
+    country: stringType().optional(),
+    site: lazyType(() => ManagedDatabasePlanAttributesSite$inboundSchema).optional(),
+    pricing: recordType(lazyType(() => ManagedDatabasePlanAttributesPricing$inboundSchema)).optional()
+  });
+  ManagedDatabasePlanAttributesRegion$outboundSchema = objectType({
+    region: stringType().optional(),
+    city: stringType().optional(),
+    country: stringType().optional(),
+    site: lazyType(() => ManagedDatabasePlanAttributesSite$outboundSchema).optional(),
+    pricing: recordType(lazyType(() => ManagedDatabasePlanAttributesPricing$outboundSchema)).optional()
+  });
+  ManagedDatabasePlanAttributesAttributes$inboundSchema = objectType({
+    name: stringType().optional(),
+    slug: stringType().optional(),
+    engine: stringType().optional(),
+    specs: lazyType(() => ManagedDatabasePlanAttributesSpecs$inboundSchema).optional(),
+    regions: arrayType(lazyType(() => ManagedDatabasePlanAttributesRegion$inboundSchema)).optional()
+  });
+  ManagedDatabasePlanAttributesAttributes$outboundSchema = objectType({
+    name: stringType().optional(),
+    slug: stringType().optional(),
+    engine: stringType().optional(),
+    specs: lazyType(() => ManagedDatabasePlanAttributesSpecs$outboundSchema).optional(),
+    regions: arrayType(lazyType(() => ManagedDatabasePlanAttributesRegion$outboundSchema)).optional()
+  });
+  ManagedDatabasePlanAttributes$inboundSchema = objectType({
+    id: stringType().optional(),
+    type: ManagedDatabasePlanAttributesType$inboundSchema.optional(),
+    attributes: lazyType(() => ManagedDatabasePlanAttributesAttributes$inboundSchema).optional()
+  });
+  ManagedDatabasePlanAttributes$outboundSchema = objectType({
+    id: stringType().optional(),
+    type: ManagedDatabasePlanAttributesType$outboundSchema.optional(),
+    attributes: lazyType(() => ManagedDatabasePlanAttributesAttributes$outboundSchema).optional()
+  });
+});
+
+// src/models/manageddatabaseplans.ts
+var ManagedDatabasePlans$inboundSchema, ManagedDatabasePlans$outboundSchema;
+var init_manageddatabaseplans = __esm(() => {
+  init_v3();
+  init_manageddatabaseplanattributes();
+  ManagedDatabasePlans$inboundSchema = objectType({
+    data: arrayType(ManagedDatabasePlanAttributes$inboundSchema).optional()
+  });
+  ManagedDatabasePlans$outboundSchema = objectType({
+    data: arrayType(ManagedDatabasePlanAttributes$outboundSchema).optional()
+  });
+});
+
 // src/models/membership.ts
 var MembershipRole, MembershipRole$inboundSchema, MembershipRole$outboundSchema, MembershipAttributes$inboundSchema, MembershipAttributes$outboundSchema, MembershipData$inboundSchema, MembershipData$outboundSchema, Membership$inboundSchema, Membership$outboundSchema;
 var init_membership = __esm(() => {
@@ -58157,19 +58255,18 @@ var init_serverrescue = __esm(() => {
 });
 
 // src/models/servers.ts
-var ServersMeta$inboundSchema, ServersMeta$outboundSchema, Servers$inboundSchema, Servers$outboundSchema;
+var Servers$inboundSchema, Servers$outboundSchema;
 var init_servers = __esm(() => {
   init_v3();
+  init_paginationmeta();
   init_serverdata();
-  ServersMeta$inboundSchema = objectType({});
-  ServersMeta$outboundSchema = objectType({});
   Servers$inboundSchema = objectType({
     data: arrayType(ServerData$inboundSchema).optional(),
-    meta: lazyType(() => ServersMeta$inboundSchema).optional()
+    meta: PaginationMeta$inboundSchema.optional()
   });
   Servers$outboundSchema = objectType({
     data: arrayType(ServerData$outboundSchema).optional(),
-    meta: lazyType(() => ServersMeta$outboundSchema).optional()
+    meta: PaginationMeta$outboundSchema.optional()
   });
 });
 
@@ -59484,6 +59581,156 @@ var init_virtualmachine = __esm(() => {
   });
 });
 
+// src/models/virtualmachinebackupattributes.ts
+var VirtualMachineBackupAttributesType, VirtualMachineBackupAttributesStatus, VirtualMachineBackupAttributesType$inboundSchema, VirtualMachineBackupAttributesType$outboundSchema, VirtualMachineBackupAttributesStatus$inboundSchema, VirtualMachineBackupAttributesStatus$outboundSchema, VirtualMachineBackupAttributesVirtualMachine$inboundSchema, VirtualMachineBackupAttributesVirtualMachine$outboundSchema, VirtualMachineBackupAttributesAttributes$inboundSchema, VirtualMachineBackupAttributesAttributes$outboundSchema, VirtualMachineBackupAttributes$inboundSchema, VirtualMachineBackupAttributes$outboundSchema;
+var init_virtualmachinebackupattributes = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_projectinclude();
+  init_teaminclude();
+  VirtualMachineBackupAttributesType = {
+    VirtualMachineBackups: "virtual_machine_backups"
+  };
+  VirtualMachineBackupAttributesStatus = {
+    Creating: "Creating",
+    Ready: "Ready",
+    Failed: "Failed",
+    Archived: "Archived"
+  };
+  VirtualMachineBackupAttributesType$inboundSchema = nativeEnumType(VirtualMachineBackupAttributesType);
+  VirtualMachineBackupAttributesType$outboundSchema = VirtualMachineBackupAttributesType$inboundSchema;
+  VirtualMachineBackupAttributesStatus$inboundSchema = nativeEnumType(VirtualMachineBackupAttributesStatus);
+  VirtualMachineBackupAttributesStatus$outboundSchema = VirtualMachineBackupAttributesStatus$inboundSchema;
+  VirtualMachineBackupAttributesVirtualMachine$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional()
+  });
+  VirtualMachineBackupAttributesVirtualMachine$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional()
+  });
+  VirtualMachineBackupAttributesAttributes$inboundSchema = objectType({
+    status: VirtualMachineBackupAttributesStatus$inboundSchema.optional(),
+    size_bytes: nullableType(numberType().int()).optional(),
+    expires_at: nullableType(stringType()).optional(),
+    failure_reason: nullableType(stringType()).optional(),
+    created_at: stringType().optional(),
+    virtual_machine: lazyType(() => VirtualMachineBackupAttributesVirtualMachine$inboundSchema).optional(),
+    team: TeamInclude$inboundSchema.optional(),
+    project: ProjectInclude$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      size_bytes: "sizeBytes",
+      expires_at: "expiresAt",
+      failure_reason: "failureReason",
+      created_at: "createdAt",
+      virtual_machine: "virtualMachine"
+    });
+  });
+  VirtualMachineBackupAttributesAttributes$outboundSchema = objectType({
+    status: VirtualMachineBackupAttributesStatus$outboundSchema.optional(),
+    sizeBytes: nullableType(numberType().int()).optional(),
+    expiresAt: nullableType(stringType()).optional(),
+    failureReason: nullableType(stringType()).optional(),
+    createdAt: stringType().optional(),
+    virtualMachine: lazyType(() => VirtualMachineBackupAttributesVirtualMachine$outboundSchema).optional(),
+    team: TeamInclude$outboundSchema.optional(),
+    project: ProjectInclude$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      sizeBytes: "size_bytes",
+      expiresAt: "expires_at",
+      failureReason: "failure_reason",
+      createdAt: "created_at",
+      virtualMachine: "virtual_machine"
+    });
+  });
+  VirtualMachineBackupAttributes$inboundSchema = objectType({
+    id: stringType().optional(),
+    type: VirtualMachineBackupAttributesType$inboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineBackupAttributesAttributes$inboundSchema).optional()
+  });
+  VirtualMachineBackupAttributes$outboundSchema = objectType({
+    id: stringType().optional(),
+    type: VirtualMachineBackupAttributesType$outboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineBackupAttributesAttributes$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinebackup.ts
+var VirtualMachineBackupMeta$inboundSchema, VirtualMachineBackupMeta$outboundSchema, VirtualMachineBackup$inboundSchema, VirtualMachineBackup$outboundSchema;
+var init_virtualmachinebackup = __esm(() => {
+  init_v3();
+  init_virtualmachinebackupattributes();
+  VirtualMachineBackupMeta$inboundSchema = objectType({});
+  VirtualMachineBackupMeta$outboundSchema = objectType({});
+  VirtualMachineBackup$inboundSchema = objectType({
+    data: VirtualMachineBackupAttributes$inboundSchema.optional(),
+    meta: lazyType(() => VirtualMachineBackupMeta$inboundSchema).optional()
+  });
+  VirtualMachineBackup$outboundSchema = objectType({
+    data: VirtualMachineBackupAttributes$outboundSchema.optional(),
+    meta: lazyType(() => VirtualMachineBackupMeta$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinebackuppayload.ts
+var VirtualMachineBackupPayloadType, VirtualMachineBackupPayloadType$inboundSchema, VirtualMachineBackupPayloadType$outboundSchema, VirtualMachineBackupPayloadAttributes$inboundSchema, VirtualMachineBackupPayloadAttributes$outboundSchema, VirtualMachineBackupPayloadData$inboundSchema, VirtualMachineBackupPayloadData$outboundSchema, VirtualMachineBackupPayload$inboundSchema, VirtualMachineBackupPayload$outboundSchema;
+var init_virtualmachinebackuppayload = __esm(() => {
+  init_v3();
+  init_primitives();
+  VirtualMachineBackupPayloadType = {
+    VirtualMachineBackups: "virtual_machine_backups"
+  };
+  VirtualMachineBackupPayloadType$inboundSchema = nativeEnumType(VirtualMachineBackupPayloadType);
+  VirtualMachineBackupPayloadType$outboundSchema = VirtualMachineBackupPayloadType$inboundSchema;
+  VirtualMachineBackupPayloadAttributes$inboundSchema = objectType({
+    virtual_machine: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtual_machine: "virtualMachine"
+    });
+  });
+  VirtualMachineBackupPayloadAttributes$outboundSchema = objectType({
+    virtualMachine: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtualMachine: "virtual_machine"
+    });
+  });
+  VirtualMachineBackupPayloadData$inboundSchema = objectType({
+    type: VirtualMachineBackupPayloadType$inboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineBackupPayloadAttributes$inboundSchema).optional()
+  });
+  VirtualMachineBackupPayloadData$outboundSchema = objectType({
+    type: VirtualMachineBackupPayloadType$outboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineBackupPayloadAttributes$outboundSchema).optional()
+  });
+  VirtualMachineBackupPayload$inboundSchema = objectType({
+    data: lazyType(() => VirtualMachineBackupPayloadData$inboundSchema).optional()
+  });
+  VirtualMachineBackupPayload$outboundSchema = objectType({
+    data: lazyType(() => VirtualMachineBackupPayloadData$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinebackups.ts
+var VirtualMachineBackupsMeta$inboundSchema, VirtualMachineBackupsMeta$outboundSchema, VirtualMachineBackups$inboundSchema, VirtualMachineBackups$outboundSchema;
+var init_virtualmachinebackups = __esm(() => {
+  init_v3();
+  init_virtualmachinebackupattributes();
+  VirtualMachineBackupsMeta$inboundSchema = objectType({});
+  VirtualMachineBackupsMeta$outboundSchema = objectType({});
+  VirtualMachineBackups$inboundSchema = objectType({
+    data: arrayType(VirtualMachineBackupAttributes$inboundSchema).optional(),
+    meta: lazyType(() => VirtualMachineBackupsMeta$inboundSchema).optional()
+  });
+  VirtualMachineBackups$outboundSchema = objectType({
+    data: arrayType(VirtualMachineBackupAttributes$outboundSchema).optional(),
+    meta: lazyType(() => VirtualMachineBackupsMeta$outboundSchema).optional()
+  });
+});
+
 // src/models/virtualmachinemetrics.ts
 var Metric, Range, VirtualMachineMetricsUnit, Metric$inboundSchema, Metric$outboundSchema, Range$inboundSchema, Range$outboundSchema, VirtualMachineMetricsUnit$inboundSchema, VirtualMachineMetricsUnit$outboundSchema, Point$inboundSchema, Point$outboundSchema, VirtualMachineMetrics$inboundSchema, VirtualMachineMetrics$outboundSchema;
 var init_virtualmachinemetrics = __esm(() => {
@@ -59898,6 +60145,146 @@ var init_virtualmachineplans = __esm(() => {
   });
 });
 
+// src/models/virtualmachinerestoreattributes.ts
+var VirtualMachineRestoreAttributesType, VirtualMachineRestoreAttributesStatus, VirtualMachineRestoreAttributesType$inboundSchema, VirtualMachineRestoreAttributesType$outboundSchema, VirtualMachineRestoreAttributesStatus$inboundSchema, VirtualMachineRestoreAttributesStatus$outboundSchema, Backup$inboundSchema, Backup$outboundSchema, VirtualMachineRestoreAttributesVirtualMachine$inboundSchema, VirtualMachineRestoreAttributesVirtualMachine$outboundSchema, VirtualMachineRestoreAttributesAttributes$inboundSchema, VirtualMachineRestoreAttributesAttributes$outboundSchema, VirtualMachineRestoreAttributes$inboundSchema, VirtualMachineRestoreAttributes$outboundSchema;
+var init_virtualmachinerestoreattributes = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_projectinclude();
+  init_teaminclude();
+  VirtualMachineRestoreAttributesType = {
+    VirtualMachineRestores: "virtual_machine_restores"
+  };
+  VirtualMachineRestoreAttributesStatus = {
+    Creating: "Creating",
+    Ready: "Ready",
+    Failed: "Failed"
+  };
+  VirtualMachineRestoreAttributesType$inboundSchema = nativeEnumType(VirtualMachineRestoreAttributesType);
+  VirtualMachineRestoreAttributesType$outboundSchema = VirtualMachineRestoreAttributesType$inboundSchema;
+  VirtualMachineRestoreAttributesStatus$inboundSchema = nativeEnumType(VirtualMachineRestoreAttributesStatus);
+  VirtualMachineRestoreAttributesStatus$outboundSchema = VirtualMachineRestoreAttributesStatus$inboundSchema;
+  Backup$inboundSchema = objectType({
+    id: stringType().optional()
+  });
+  Backup$outboundSchema = objectType({
+    id: stringType().optional()
+  });
+  VirtualMachineRestoreAttributesVirtualMachine$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional()
+  });
+  VirtualMachineRestoreAttributesVirtualMachine$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional()
+  });
+  VirtualMachineRestoreAttributesAttributes$inboundSchema = objectType({
+    status: VirtualMachineRestoreAttributesStatus$inboundSchema.optional(),
+    created_at: stringType().optional(),
+    backup: lazyType(() => Backup$inboundSchema).optional(),
+    virtual_machine: nullableType(lazyType(() => VirtualMachineRestoreAttributesVirtualMachine$inboundSchema)).optional(),
+    team: TeamInclude$inboundSchema.optional(),
+    project: ProjectInclude$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      created_at: "createdAt",
+      virtual_machine: "virtualMachine"
+    });
+  });
+  VirtualMachineRestoreAttributesAttributes$outboundSchema = objectType({
+    status: VirtualMachineRestoreAttributesStatus$outboundSchema.optional(),
+    createdAt: stringType().optional(),
+    backup: lazyType(() => Backup$outboundSchema).optional(),
+    virtualMachine: nullableType(lazyType(() => VirtualMachineRestoreAttributesVirtualMachine$outboundSchema)).optional(),
+    team: TeamInclude$outboundSchema.optional(),
+    project: ProjectInclude$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      createdAt: "created_at",
+      virtualMachine: "virtual_machine"
+    });
+  });
+  VirtualMachineRestoreAttributes$inboundSchema = objectType({
+    id: stringType().optional(),
+    type: VirtualMachineRestoreAttributesType$inboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineRestoreAttributesAttributes$inboundSchema).optional()
+  });
+  VirtualMachineRestoreAttributes$outboundSchema = objectType({
+    id: stringType().optional(),
+    type: VirtualMachineRestoreAttributesType$outboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineRestoreAttributesAttributes$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinerestore.ts
+var VirtualMachineRestoreMeta$inboundSchema, VirtualMachineRestoreMeta$outboundSchema, VirtualMachineRestore$inboundSchema, VirtualMachineRestore$outboundSchema;
+var init_virtualmachinerestore = __esm(() => {
+  init_v3();
+  init_virtualmachinerestoreattributes();
+  VirtualMachineRestoreMeta$inboundSchema = objectType({});
+  VirtualMachineRestoreMeta$outboundSchema = objectType({});
+  VirtualMachineRestore$inboundSchema = objectType({
+    data: VirtualMachineRestoreAttributes$inboundSchema.optional(),
+    meta: lazyType(() => VirtualMachineRestoreMeta$inboundSchema).optional()
+  });
+  VirtualMachineRestore$outboundSchema = objectType({
+    data: VirtualMachineRestoreAttributes$outboundSchema.optional(),
+    meta: lazyType(() => VirtualMachineRestoreMeta$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinerestorepayload.ts
+var VirtualMachineRestorePayloadType, VirtualMachineRestorePayloadType$inboundSchema, VirtualMachineRestorePayloadType$outboundSchema, VirtualMachineRestorePayloadAttributes$inboundSchema, VirtualMachineRestorePayloadAttributes$outboundSchema, VirtualMachineRestorePayloadData$inboundSchema, VirtualMachineRestorePayloadData$outboundSchema, VirtualMachineRestorePayload$inboundSchema, VirtualMachineRestorePayload$outboundSchema;
+var init_virtualmachinerestorepayload = __esm(() => {
+  init_v3();
+  VirtualMachineRestorePayloadType = {
+    VirtualMachineRestores: "virtual_machine_restores"
+  };
+  VirtualMachineRestorePayloadType$inboundSchema = nativeEnumType(VirtualMachineRestorePayloadType);
+  VirtualMachineRestorePayloadType$outboundSchema = VirtualMachineRestorePayloadType$inboundSchema;
+  VirtualMachineRestorePayloadAttributes$inboundSchema = objectType({
+    backup: stringType().optional(),
+    name: nullableType(stringType()).optional(),
+    site: nullableType(stringType()).optional()
+  });
+  VirtualMachineRestorePayloadAttributes$outboundSchema = objectType({
+    backup: stringType().optional(),
+    name: nullableType(stringType()).optional(),
+    site: nullableType(stringType()).optional()
+  });
+  VirtualMachineRestorePayloadData$inboundSchema = objectType({
+    type: VirtualMachineRestorePayloadType$inboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineRestorePayloadAttributes$inboundSchema).optional()
+  });
+  VirtualMachineRestorePayloadData$outboundSchema = objectType({
+    type: VirtualMachineRestorePayloadType$outboundSchema.optional(),
+    attributes: lazyType(() => VirtualMachineRestorePayloadAttributes$outboundSchema).optional()
+  });
+  VirtualMachineRestorePayload$inboundSchema = objectType({
+    data: lazyType(() => VirtualMachineRestorePayloadData$inboundSchema).optional()
+  });
+  VirtualMachineRestorePayload$outboundSchema = objectType({
+    data: lazyType(() => VirtualMachineRestorePayloadData$outboundSchema).optional()
+  });
+});
+
+// src/models/virtualmachinerestores.ts
+var VirtualMachineRestoresMeta$inboundSchema, VirtualMachineRestoresMeta$outboundSchema, VirtualMachineRestores$inboundSchema, VirtualMachineRestores$outboundSchema;
+var init_virtualmachinerestores = __esm(() => {
+  init_v3();
+  init_virtualmachinerestoreattributes();
+  VirtualMachineRestoresMeta$inboundSchema = objectType({});
+  VirtualMachineRestoresMeta$outboundSchema = objectType({});
+  VirtualMachineRestores$inboundSchema = objectType({
+    data: arrayType(VirtualMachineRestoreAttributes$inboundSchema).optional(),
+    meta: lazyType(() => VirtualMachineRestoresMeta$inboundSchema).optional()
+  });
+  VirtualMachineRestores$outboundSchema = objectType({
+    data: arrayType(VirtualMachineRestoreAttributes$outboundSchema).optional(),
+    meta: lazyType(() => VirtualMachineRestoresMeta$outboundSchema).optional()
+  });
+});
+
 // src/models/virtualmachines.ts
 var VirtualMachinesMeta$inboundSchema, VirtualMachinesMeta$outboundSchema, VirtualMachines$inboundSchema, VirtualMachines$outboundSchema;
 var init_virtualmachines = __esm(() => {
@@ -59916,21 +60303,32 @@ var init_virtualmachines = __esm(() => {
 });
 
 // src/models/virtualmachineupdatepayload.ts
-var VirtualMachineUpdatePayloadType, VirtualMachineUpdatePayloadType$inboundSchema, VirtualMachineUpdatePayloadType$outboundSchema, VirtualMachineUpdatePayloadAttributes$inboundSchema, VirtualMachineUpdatePayloadAttributes$outboundSchema, VirtualMachineUpdatePayloadData$inboundSchema, VirtualMachineUpdatePayloadData$outboundSchema, VirtualMachineUpdatePayload$inboundSchema, VirtualMachineUpdatePayload$outboundSchema;
+var VirtualMachineUpdatePayloadType, BillingEnum, VirtualMachineUpdatePayloadType$inboundSchema, VirtualMachineUpdatePayloadType$outboundSchema, BillingEnum$inboundSchema, BillingEnum$outboundSchema, VirtualMachineUpdatePayloadAttributes$inboundSchema, VirtualMachineUpdatePayloadAttributes$outboundSchema, VirtualMachineUpdatePayloadData$inboundSchema, VirtualMachineUpdatePayloadData$outboundSchema, VirtualMachineUpdatePayload$inboundSchema, VirtualMachineUpdatePayload$outboundSchema;
 var init_virtualmachineupdatepayload = __esm(() => {
   init_v3();
   VirtualMachineUpdatePayloadType = {
     VirtualMachines: "virtual_machines"
   };
+  BillingEnum = {
+    Hourly: "hourly",
+    Monthly: "monthly",
+    Yearly: "yearly"
+  };
   VirtualMachineUpdatePayloadType$inboundSchema = nativeEnumType(VirtualMachineUpdatePayloadType);
   VirtualMachineUpdatePayloadType$outboundSchema = VirtualMachineUpdatePayloadType$inboundSchema;
+  BillingEnum$inboundSchema = nativeEnumType(BillingEnum);
+  BillingEnum$outboundSchema = BillingEnum$inboundSchema;
   VirtualMachineUpdatePayloadAttributes$inboundSchema = objectType({
     name: stringType().optional(),
-    tags: nullableType(arrayType(stringType())).optional()
+    tags: nullableType(arrayType(stringType())).optional(),
+    billing: BillingEnum$inboundSchema.optional(),
+    plan: stringType().optional()
   });
   VirtualMachineUpdatePayloadAttributes$outboundSchema = objectType({
     name: stringType().optional(),
-    tags: nullableType(arrayType(stringType())).optional()
+    tags: nullableType(arrayType(stringType())).optional(),
+    billing: BillingEnum$outboundSchema.optional(),
+    plan: stringType().optional()
   });
   VirtualMachineUpdatePayloadData$inboundSchema = objectType({
     type: VirtualMachineUpdatePayloadType$inboundSchema,
@@ -59986,14 +60384,14 @@ var init_virtualnetworkdata = __esm(() => {
   VirtualNetworkDataTag$inboundSchema = objectType({
     id: stringType().optional(),
     name: stringType().optional(),
-    description: stringType().optional(),
-    color: stringType().optional()
+    description: nullableType(stringType()).optional(),
+    color: nullableType(stringType()).optional()
   });
   VirtualNetworkDataTag$outboundSchema = objectType({
     id: stringType().optional(),
     name: stringType().optional(),
-    description: stringType().optional(),
-    color: stringType().optional()
+    description: nullableType(stringType()).optional(),
+    color: nullableType(stringType()).optional()
   });
   VirtualNetworkDataAttributes$inboundSchema = objectType({
     vid: numberType().int().optional(),
@@ -60130,36 +60528,34 @@ var init_virtualnetworkassignment = __esm(() => {
 });
 
 // src/models/virtualnetworkassignments.ts
-var VirtualNetworkAssignmentsMeta$inboundSchema, VirtualNetworkAssignmentsMeta$outboundSchema, VirtualNetworkAssignments$inboundSchema, VirtualNetworkAssignments$outboundSchema;
+var VirtualNetworkAssignments$inboundSchema, VirtualNetworkAssignments$outboundSchema;
 var init_virtualnetworkassignments = __esm(() => {
   init_v3();
+  init_paginationmeta();
   init_virtualnetworkassignmentdata();
-  VirtualNetworkAssignmentsMeta$inboundSchema = objectType({});
-  VirtualNetworkAssignmentsMeta$outboundSchema = objectType({});
   VirtualNetworkAssignments$inboundSchema = objectType({
     data: arrayType(VirtualNetworkAssignmentData$inboundSchema).optional(),
-    meta: lazyType(() => VirtualNetworkAssignmentsMeta$inboundSchema).optional()
+    meta: PaginationMeta$inboundSchema.optional()
   });
   VirtualNetworkAssignments$outboundSchema = objectType({
     data: arrayType(VirtualNetworkAssignmentData$outboundSchema).optional(),
-    meta: lazyType(() => VirtualNetworkAssignmentsMeta$outboundSchema).optional()
+    meta: PaginationMeta$outboundSchema.optional()
   });
 });
 
 // src/models/virtualnetworks.ts
-var VirtualNetworksMeta$inboundSchema, VirtualNetworksMeta$outboundSchema, VirtualNetworks$inboundSchema, VirtualNetworks$outboundSchema;
+var VirtualNetworks$inboundSchema, VirtualNetworks$outboundSchema;
 var init_virtualnetworks = __esm(() => {
   init_v3();
+  init_paginationmeta();
   init_virtualnetworkdata();
-  VirtualNetworksMeta$inboundSchema = objectType({});
-  VirtualNetworksMeta$outboundSchema = objectType({});
   VirtualNetworks$inboundSchema = objectType({
     data: arrayType(VirtualNetworkData$inboundSchema).optional(),
-    meta: lazyType(() => VirtualNetworksMeta$inboundSchema).optional()
+    meta: PaginationMeta$inboundSchema.optional()
   });
   VirtualNetworks$outboundSchema = objectType({
     data: arrayType(VirtualNetworkData$outboundSchema).optional(),
-    meta: lazyType(() => VirtualNetworksMeta$outboundSchema).optional()
+    meta: PaginationMeta$outboundSchema.optional()
   });
 });
 
@@ -60346,6 +60742,8 @@ var init_models = __esm(() => {
   init_kubernetesclusters();
   init_kubernetesclustersummarydata();
   init_kubernetesclusterupdateresponse();
+  init_manageddatabaseplanattributes();
+  init_manageddatabaseplans();
   init_membership();
   init_objectstoragedata();
   init_objectstorages();
@@ -60394,12 +60792,20 @@ var init_models = __esm(() => {
   init_userupdate();
   init_virtualmachine();
   init_virtualmachineattributes();
+  init_virtualmachinebackup();
+  init_virtualmachinebackupattributes();
+  init_virtualmachinebackuppayload();
+  init_virtualmachinebackups();
   init_virtualmachinemetrics();
   init_virtualmachinenetworkattachmentcreatepayload();
   init_virtualmachinenetworkattachmentresource();
   init_virtualmachinenetworkattachments();
   init_virtualmachinepayload();
   init_virtualmachineplans();
+  init_virtualmachinerestore();
+  init_virtualmachinerestoreattributes();
+  init_virtualmachinerestorepayload();
+  init_virtualmachinerestores();
   init_virtualmachines();
   init_virtualmachineupdatepayload();
   init_virtualnetwork();
@@ -61212,6 +61618,27 @@ var init_createvirtualmachineaction = __esm(() => {
   });
 });
 
+// src/models/operations/createvirtualmachinebackup.ts
+var CreateVirtualMachineBackupRequest$inboundSchema, CreateVirtualMachineBackupRequest$outboundSchema;
+var init_createvirtualmachinebackup = __esm(() => {
+  init_v3();
+  init_primitives();
+  CreateVirtualMachineBackupRequest$inboundSchema = objectType({
+    virtual_machine_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtual_machine_id: "virtualMachineId"
+    });
+  });
+  CreateVirtualMachineBackupRequest$outboundSchema = objectType({
+    virtualMachineId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtualMachineId: "virtual_machine_id"
+    });
+  });
+});
+
 // src/models/operations/createvirtualmachinenetworkattachment.ts
 var CreateVirtualMachineNetworkAttachmentRequest$inboundSchema, CreateVirtualMachineNetworkAttachmentRequest$outboundSchema, CreateVirtualMachineNetworkAttachmentMeta$inboundSchema, CreateVirtualMachineNetworkAttachmentMeta$outboundSchema, CreateVirtualMachineNetworkAttachmentResponse$inboundSchema, CreateVirtualMachineNetworkAttachmentResponse$outboundSchema;
 var init_createvirtualmachinenetworkattachment = __esm(() => {
@@ -61250,6 +61677,36 @@ var init_createvirtualmachinenetworkattachment = __esm(() => {
   });
 });
 
+// src/models/operations/createvirtualmachinerestore.ts
+var CreateVirtualMachineRestoreRequest$inboundSchema, CreateVirtualMachineRestoreRequest$outboundSchema;
+var init_createvirtualmachinerestore = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_models();
+  CreateVirtualMachineRestoreRequest$inboundSchema = objectType({
+    virtual_machine_id: stringType(),
+    backup_id: stringType(),
+    virtual_machine_restore_payload: VirtualMachineRestorePayload$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtual_machine_id: "virtualMachineId",
+      backup_id: "backupId",
+      virtual_machine_restore_payload: "virtualMachineRestorePayload"
+    });
+  });
+  CreateVirtualMachineRestoreRequest$outboundSchema = objectType({
+    virtualMachineId: stringType(),
+    backupId: stringType(),
+    virtualMachineRestorePayload: VirtualMachineRestorePayload$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtualMachineId: "virtual_machine_id",
+      backupId: "backup_id",
+      virtualMachineRestorePayload: "virtual_machine_restore_payload"
+    });
+  });
+});
+
 // src/models/operations/createvirtualnetwork.ts
 var CreateVirtualNetworkType2, CreateVirtualNetworkSite2, CreateVirtualNetworkType2$inboundSchema, CreateVirtualNetworkType2$outboundSchema, CreateVirtualNetworkSite2$inboundSchema, CreateVirtualNetworkSite2$outboundSchema, CreateVirtualNetworkAttributes2$inboundSchema, CreateVirtualNetworkAttributes2$outboundSchema, CreateVirtualNetworkData2$inboundSchema, CreateVirtualNetworkData2$outboundSchema, CreateVirtualNetworkRequest$inboundSchema, CreateVirtualNetworkRequest$outboundSchema;
 var init_createvirtualnetwork = __esm(() => {
@@ -61574,6 +62031,18 @@ var init_deleteuserdata = __esm(() => {
   });
 });
 
+// src/models/operations/deletevirtualmachinebackup.ts
+var DeleteVirtualMachineBackupRequest$inboundSchema, DeleteVirtualMachineBackupRequest$outboundSchema;
+var init_deletevirtualmachinebackup = __esm(() => {
+  init_v3();
+  DeleteVirtualMachineBackupRequest$inboundSchema = objectType({
+    id: stringType()
+  });
+  DeleteVirtualMachineBackupRequest$outboundSchema = objectType({
+    id: stringType()
+  });
+});
+
 // src/models/operations/deletevirtualnetworksassignments.ts
 var DeleteVirtualNetworksAssignmentsRequest$inboundSchema, DeleteVirtualNetworksAssignmentsRequest$outboundSchema;
 var init_deletevirtualnetworksassignments = __esm(() => {
@@ -62724,6 +63193,7 @@ var init_getservers = __esm(() => {
     "filter[disk][lte]": numberType().int().optional(),
     "filter[tags]": stringType().optional(),
     "extra_fields[servers]": stringType().optional(),
+    "stats[total]": stringType().optional(),
     "page[size]": numberType().int().default(20),
     "page[number]": numberType().int().default(1)
   }).transform((v2) => {
@@ -62745,6 +63215,7 @@ var init_getservers = __esm(() => {
       "filter[disk][lte]": "filterDiskLte",
       "filter[tags]": "filterTags",
       "extra_fields[servers]": "extraFieldsServers",
+      "stats[total]": "statsTotal",
       "page[size]": "pageSize",
       "page[number]": "pageNumber"
     });
@@ -62767,6 +63238,7 @@ var init_getservers = __esm(() => {
     filterDiskLte: numberType().int().optional(),
     filterTags: stringType().optional(),
     extraFieldsServers: stringType().optional(),
+    statsTotal: stringType().optional(),
     pageSize: numberType().int().default(20),
     pageNumber: numberType().int().default(1)
   }).transform((v2) => {
@@ -62788,6 +63260,7 @@ var init_getservers = __esm(() => {
       filterDiskLte: "filter[disk][lte]",
       filterTags: "filter[tags]",
       extraFieldsServers: "extra_fields[servers]",
+      statsTotal: "stats[total]",
       pageSize: "page[size]",
       pageNumber: "page[number]"
     });
@@ -63173,6 +63646,30 @@ var init_getusersdata = __esm(() => {
   });
 });
 
+// src/models/operations/getvirtualmachinebackup.ts
+var GetVirtualMachineBackupRequest$inboundSchema, GetVirtualMachineBackupRequest$outboundSchema;
+var init_getvirtualmachinebackup = __esm(() => {
+  init_v3();
+  GetVirtualMachineBackupRequest$inboundSchema = objectType({
+    id: stringType()
+  });
+  GetVirtualMachineBackupRequest$outboundSchema = objectType({
+    id: stringType()
+  });
+});
+
+// src/models/operations/getvirtualmachinerestore.ts
+var GetVirtualMachineRestoreRequest$inboundSchema, GetVirtualMachineRestoreRequest$outboundSchema;
+var init_getvirtualmachinerestore = __esm(() => {
+  init_v3();
+  GetVirtualMachineRestoreRequest$inboundSchema = objectType({
+    id: stringType()
+  });
+  GetVirtualMachineRestoreRequest$outboundSchema = objectType({
+    id: stringType()
+  });
+});
+
 // src/models/operations/getvirtualnetwork.ts
 var GetVirtualNetworkRequest$inboundSchema, GetVirtualNetworkRequest$outboundSchema;
 var init_getvirtualnetwork = __esm(() => {
@@ -63204,6 +63701,7 @@ var init_getvirtualnetworks = __esm(() => {
     "filter[location]": stringType().optional(),
     "filter[project]": stringType().optional(),
     "filter[tags]": stringType().optional(),
+    "stats[total]": stringType().optional(),
     "page[size]": numberType().int().default(20),
     "page[number]": numberType().int().default(1)
   }).transform((v2) => {
@@ -63211,6 +63709,7 @@ var init_getvirtualnetworks = __esm(() => {
       "filter[location]": "filterLocation",
       "filter[project]": "filterProject",
       "filter[tags]": "filterTags",
+      "stats[total]": "statsTotal",
       "page[size]": "pageSize",
       "page[number]": "pageNumber"
     });
@@ -63219,6 +63718,7 @@ var init_getvirtualnetworks = __esm(() => {
     filterLocation: stringType().optional(),
     filterProject: stringType().optional(),
     filterTags: stringType().optional(),
+    statsTotal: stringType().optional(),
     pageSize: numberType().int().default(20),
     pageNumber: numberType().int().default(1)
   }).transform((v2) => {
@@ -63226,6 +63726,7 @@ var init_getvirtualnetworks = __esm(() => {
       filterLocation: "filter[location]",
       filterProject: "filter[project]",
       filterTags: "filter[tags]",
+      statsTotal: "stats[total]",
       pageSize: "page[size]",
       pageNumber: "page[number]"
     });
@@ -63256,6 +63757,7 @@ var init_getvirtualnetworksassignments = __esm(() => {
     "filter[server]": stringType().optional(),
     "filter[vid]": stringType().optional(),
     "filter[virtual_network_id]": stringType().optional(),
+    "stats[total]": stringType().optional(),
     "page[size]": numberType().int().default(20),
     "page[number]": numberType().int().default(1)
   }).transform((v2) => {
@@ -63263,6 +63765,7 @@ var init_getvirtualnetworksassignments = __esm(() => {
       "filter[server]": "filterServer",
       "filter[vid]": "filterVid",
       "filter[virtual_network_id]": "filterVirtualNetworkId",
+      "stats[total]": "statsTotal",
       "page[size]": "pageSize",
       "page[number]": "pageNumber"
     });
@@ -63271,6 +63774,7 @@ var init_getvirtualnetworksassignments = __esm(() => {
     filterServer: stringType().optional(),
     filterVid: stringType().optional(),
     filterVirtualNetworkId: stringType().optional(),
+    statsTotal: stringType().optional(),
     pageSize: numberType().int().default(20),
     pageNumber: numberType().int().default(1)
   }).transform((v2) => {
@@ -63278,6 +63782,7 @@ var init_getvirtualnetworksassignments = __esm(() => {
       filterServer: "filter[server]",
       filterVid: "filter[vid]",
       filterVirtualNetworkId: "filter[virtual_network_id]",
+      statsTotal: "stats[total]",
       pageSize: "page[size]",
       pageNumber: "page[number]"
     });
@@ -63402,6 +63907,27 @@ var init_indexvirtualmachine = __esm(() => {
   });
 });
 
+// src/models/operations/listbackuprestores.ts
+var ListBackupRestoresRequest$inboundSchema, ListBackupRestoresRequest$outboundSchema;
+var init_listbackuprestores = __esm(() => {
+  init_v3();
+  init_primitives();
+  ListBackupRestoresRequest$inboundSchema = objectType({
+    backup_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      backup_id: "backupId"
+    });
+  });
+  ListBackupRestoresRequest$outboundSchema = objectType({
+    backupId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      backupId: "backup_id"
+    });
+  });
+});
+
 // src/models/operations/listelasticips.ts
 var FilterStatus, FilterStatus$inboundSchema, FilterStatus$outboundSchema, ListElasticIpsRequest$inboundSchema, ListElasticIpsRequest$outboundSchema, ListElasticIpsResponse$inboundSchema, ListElasticIpsResponse$outboundSchema;
 var init_listelasticips = __esm(() => {
@@ -63549,6 +64075,52 @@ var init_listvirtualmachinenetworkattachments = __esm(() => {
   });
 });
 
+// src/models/operations/listvirtualmachinescopedbackups.ts
+var ListVirtualMachineScopedBackupsRequest$inboundSchema, ListVirtualMachineScopedBackupsRequest$outboundSchema;
+var init_listvirtualmachinescopedbackups = __esm(() => {
+  init_v3();
+  init_primitives();
+  ListVirtualMachineScopedBackupsRequest$inboundSchema = objectType({
+    virtual_machine_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtual_machine_id: "virtualMachineId"
+    });
+  });
+  ListVirtualMachineScopedBackupsRequest$outboundSchema = objectType({
+    virtualMachineId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtualMachineId: "virtual_machine_id"
+    });
+  });
+});
+
+// src/models/operations/listvirtualmachinescopedrestores.ts
+var ListVirtualMachineScopedRestoresRequest$inboundSchema, ListVirtualMachineScopedRestoresRequest$outboundSchema;
+var init_listvirtualmachinescopedrestores = __esm(() => {
+  init_v3();
+  init_primitives();
+  ListVirtualMachineScopedRestoresRequest$inboundSchema = objectType({
+    virtual_machine_id: stringType(),
+    backup_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtual_machine_id: "virtualMachineId",
+      backup_id: "backupId"
+    });
+  });
+  ListVirtualMachineScopedRestoresRequest$outboundSchema = objectType({
+    virtualMachineId: stringType(),
+    backupId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      virtualMachineId: "virtual_machine_id",
+      backupId: "backup_id"
+    });
+  });
+});
+
 // src/models/operations/patchcurrentteam.ts
 var PatchCurrentTeamType2, PatchCurrentTeamType2$inboundSchema, PatchCurrentTeamType2$outboundSchema, PatchCurrentTeamAttributes2$inboundSchema, PatchCurrentTeamAttributes2$outboundSchema, PatchCurrentTeamData2$inboundSchema, PatchCurrentTeamData2$outboundSchema, PatchCurrentTeamRequestBody2$inboundSchema, PatchCurrentTeamRequestBody2$outboundSchema, PatchCurrentTeamRequest$inboundSchema, PatchCurrentTeamRequest$outboundSchema, PatchCurrentTeamResponse$inboundSchema, PatchCurrentTeamResponse$outboundSchema;
 var init_patchcurrentteam = __esm(() => {
@@ -64822,17 +65394,21 @@ var init_showvirtualmachine = __esm(() => {
   init_v3();
   init_primitives();
   ShowVirtualMachineRequest$inboundSchema = objectType({
-    virtual_machine_id: stringType()
+    virtual_machine_id: stringType(),
+    "extra_fields[virtual_machines]": stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
-      virtual_machine_id: "virtualMachineId"
+      virtual_machine_id: "virtualMachineId",
+      "extra_fields[virtual_machines]": "extraFieldsVirtualMachines"
     });
   });
   ShowVirtualMachineRequest$outboundSchema = objectType({
-    virtualMachineId: stringType()
+    virtualMachineId: stringType(),
+    extraFieldsVirtualMachines: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
-      virtualMachineId: "virtual_machine_id"
+      virtualMachineId: "virtual_machine_id",
+      extraFieldsVirtualMachines: "extra_fields[virtual_machines]"
     });
   });
 });
@@ -65540,7 +66116,9 @@ var init_operations = __esm(() => {
   init_createserverreinstall();
   init_createtag();
   init_createvirtualmachineaction();
+  init_createvirtualmachinebackup();
   init_createvirtualmachinenetworkattachment();
+  init_createvirtualmachinerestore();
   init_createvirtualnetwork();
   init_deleteapikey();
   init_deleteelasticip();
@@ -65555,6 +66133,7 @@ var init_operations = __esm(() => {
   init_deletestoragefilesystems();
   init_deletestoragevolumes();
   init_deleteuserdata();
+  init_deletevirtualmachinebackup();
   init_deletevirtualnetworksassignments();
   init_deletevpnsession();
   init_destroyserver();
@@ -65603,16 +66182,21 @@ var init_operations = __esm(() => {
   init_getuserdata();
   init_getuserprofile();
   init_getusersdata();
+  init_getvirtualmachinebackup();
+  init_getvirtualmachinerestore();
   init_getvirtualnetwork();
   init_getvirtualnetworks();
   init_getvirtualnetworksassignments();
   init_getvmplans();
   init_getvpnsessions();
   init_indexvirtualmachine();
+  init_listbackuprestores();
   init_listelasticips();
   init_listfirewalls();
   init_listkubernetesclusters();
   init_listvirtualmachinenetworkattachments();
+  init_listvirtualmachinescopedbackups();
+  init_listvirtualmachinescopedrestores();
   init_patchcurrentteam();
   init_patchstoragefilesystems();
   init_patchuserdata();
@@ -71067,11 +71651,96 @@ Lists all bandwidth plans.`,
   };
 });
 
+// src/funcs/plansGetManagedDatabasePlans.ts
+function plansGetManagedDatabasePlans(client, options) {
+  return new APIPromise($do47(client, options));
+}
+async function $do47(client, options) {
+  const path = pathToFunc("/plans/managed_databases")();
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "get-managed-database-plans",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, ManagedDatabasePlans$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_plansGetManagedDatabasePlans = __esm(() => {
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_security();
+  init_url();
+  init_models();
+  init_async();
+});
+
+// src/mcp-server/tools/plansGetManagedDatabasePlans.ts
+var tool$plansGetManagedDatabasePlans;
+var init_plansGetManagedDatabasePlans2 = __esm(() => {
+  init_plansGetManagedDatabasePlans();
+  init_tools();
+  tool$plansGetManagedDatabasePlans = {
+    name: "plans-get-managed-database-plans",
+    description: `List managed database plans`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await plansGetManagedDatabasePlans(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
 // src/funcs/plansList.ts
 function plansList(client, request, options) {
-  return new APIPromise($do47(client, request, options));
+  return new APIPromise($do48(client, request, options));
 }
-async function $do47(client, request, options) {
+async function $do48(client, request, options) {
   const parsed = safeParse4(request, (value) => GetPlansRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71182,9 +71851,9 @@ Lists all plans. Availability by region is included in \`attributes.regions.loca
 
 // src/funcs/plansListStorage.ts
 function plansListStorage(client, options) {
-  return new APIPromise($do48(client, options));
+  return new APIPromise($do49(client, options));
 }
-async function $do48(client, options) {
+async function $do49(client, options) {
   const path = pathToFunc("/plans/storage")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -71267,9 +71936,9 @@ var init_plansListStorage2 = __esm(() => {
 
 // src/funcs/plansUpdateBandwidth.ts
 function plansUpdateBandwidth(client, request, options) {
-  return new APIPromise($do49(client, request, options));
+  return new APIPromise($do50(client, request, options));
 }
-async function $do49(client, request, options) {
+async function $do50(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdatePlansBandwidthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71371,9 +72040,9 @@ Allows to increase or decrease bandwidth packages. Only admins and owners can re
 
 // src/funcs/plansVmList.ts
 function plansVmList(client, request, options) {
-  return new APIPromise($do50(client, request, options));
+  return new APIPromise($do51(client, request, options));
 }
-async function $do50(client, request, options) {
+async function $do51(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVmPlansRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71475,9 +72144,9 @@ var init_plansVmList2 = __esm(() => {
 
 // src/funcs/privateNetworksAssign.ts
 function privateNetworksAssign(client, request, options) {
-  return new APIPromise($do51(client, request, options));
+  return new APIPromise($do52(client, request, options));
 }
-async function $do51(client, request, options) {
+async function $do52(client, request, options) {
   const parsed = safeParse4(request, (value) => AssignServerVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71576,9 +72245,9 @@ var init_privateNetworksAssign2 = __esm(() => {
 
 // src/funcs/privateNetworksCreate.ts
 function privateNetworksCreate(client, request, options) {
-  return new APIPromise($do52(client, request, options));
+  return new APIPromise($do53(client, request, options));
 }
-async function $do52(client, request, options) {
+async function $do53(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71680,9 +72349,9 @@ Creates a new Virtual Network.
 
 // src/funcs/privateNetworksDeleteAssignment.ts
 function privateNetworksDeleteAssignment(client, request, options) {
-  return new APIPromise($do53(client, request, options));
+  return new APIPromise($do54(client, request, options));
 }
-async function $do53(client, request, options) {
+async function $do54(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVirtualNetworksAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71786,9 +72455,9 @@ Allow you to remove a Virtual Network assignment.
 
 // src/funcs/privateNetworksGet.ts
 function privateNetworksGet(client, request, options) {
-  return new APIPromise($do54(client, request, options));
+  return new APIPromise($do55(client, request, options));
 }
-async function $do54(client, request, options) {
+async function $do55(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71895,9 +72564,9 @@ Retrieve a Virtual Network.
 
 // src/funcs/privateNetworksList.ts
 function privateNetworksList(client, request, options) {
-  return new APIPromise($do55(client, request, options));
+  return new APIPromise($do56(client, request, options));
 }
-async function $do55(client, request, options) {
+async function $do56(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworksRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -71910,7 +72579,8 @@ async function $do55(client, request, options) {
     "filter[project]": payload?.["filter[project]"],
     "filter[tags]": payload?.["filter[tags]"],
     "page[number]": payload?.["page[number]"],
-    "page[size]": payload?.["page[size]"]
+    "page[size]": payload?.["page[size]"],
+    "stats[total]": payload?.["stats[total]"]
   });
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -72039,9 +72709,9 @@ Lists virtual networks assigned to a project
 
 // src/funcs/privateNetworksListAssignments.ts
 function privateNetworksListAssignments(client, request, options) {
-  return new APIPromise($do56(client, request, options));
+  return new APIPromise($do57(client, request, options));
 }
-async function $do56(client, request, options) {
+async function $do57(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworksAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -72054,7 +72724,8 @@ async function $do56(client, request, options) {
     "filter[vid]": payload?.["filter[vid]"],
     "filter[virtual_network_id]": payload?.["filter[virtual_network_id]"],
     "page[number]": payload?.["page[number]"],
-    "page[size]": payload?.["page[size]"]
+    "page[size]": payload?.["page[size]"],
+    "stats[total]": payload?.["stats[total]"]
   });
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -72180,9 +72851,9 @@ Returns a list of all servers assigned to virtual networks.
 
 // src/funcs/privateNetworksUpdate.ts
 function privateNetworksUpdate(client, request, options) {
-  return new APIPromise($do57(client, request, options));
+  return new APIPromise($do58(client, request, options));
 }
-async function $do57(client, request, options) {
+async function $do58(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72290,9 +72961,9 @@ Update a Virtual Network.
 
 // src/funcs/projectsCreate.ts
 function projectsCreate(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do59(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do59(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72390,9 +73061,9 @@ var init_projectsCreate2 = __esm(() => {
 
 // src/funcs/projectsDelete.ts
 function projectsDelete(client, request, options) {
-  return new APIPromise($do59(client, request, options));
+  return new APIPromise($do60(client, request, options));
 }
-async function $do59(client, request, options) {
+async function $do60(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72495,9 +73166,9 @@ Deletes a project and releases associated resources. Any Elastic IPs assigned to
 
 // src/funcs/projectsList.ts
 function projectsList(client, request, options) {
-  return new APIPromise($do60(client, request, options));
+  return new APIPromise($do61(client, request, options));
 }
-async function $do60(client, request, options) {
+async function $do61(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -72643,9 +73314,9 @@ Returns a list of all projects for the current team
 
 // src/funcs/projectsSshKeysPostProjectSshKey.ts
 function projectsSshKeysPostProjectSshKey(client, request, options) {
-  return new APIPromise($do61(client, request, options));
+  return new APIPromise($do62(client, request, options));
 }
-async function $do61(client, request, options) {
+async function $do62(client, request, options) {
   const parsed = safeParse4(request, (value) => PostProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72752,9 +73423,9 @@ Allow you create SSH Keys in a project. These keys can be used to access servers
 
 // src/funcs/projectsUpdate.ts
 function projectsUpdate(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do63(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do63(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72858,9 +73529,9 @@ var init_projectsUpdate2 = __esm(() => {
 
 // src/funcs/regionsFetch.ts
 function regionsFetch(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRegionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72964,9 +73635,9 @@ var init_regionsFetch2 = __esm(() => {
 
 // src/funcs/regionsGet.ts
 function regionsGet(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRegionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -73106,9 +73777,9 @@ Lists all [available locations](https://latitude.sh/locations). For server avail
 
 // src/funcs/rolesGet.ts
 function rolesGet(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRoleIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73212,9 +73883,9 @@ var init_rolesGet2 = __esm(() => {
 
 // src/funcs/rolesList.ts
 function rolesList(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRolesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -73353,9 +74024,9 @@ Returns a list of all roles that can be assigned to users
 
 // src/funcs/serversCreate.ts
 function serversCreate(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do68(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do68(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73454,9 +74125,9 @@ var init_serversCreate2 = __esm(() => {
 
 // src/funcs/serversCreateIpmiSession.ts
 function serversCreateIpmiSession(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateIpmiSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73566,9 +74237,9 @@ Related guide: https://docs.latitude.sh/docs/ipmi
 
 // src/funcs/serversDelete.ts
 function serversDelete(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73673,9 +74344,9 @@ var init_serversDelete2 = __esm(() => {
 
 // src/funcs/serversExitRescueMode.ts
 function serversExitRescueMode(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerExitRescueModeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73781,9 +74452,9 @@ Exits rescue mode on a given server.`,
 
 // src/funcs/serversGet.ts
 function serversGet(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73894,9 +74565,9 @@ Returns a server that belongs to the team.
 
 // src/funcs/serversGetDeployConfig.ts
 function serversGetDeployConfig(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerDeployConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74000,9 +74671,9 @@ var init_serversGetDeployConfig2 = __esm(() => {
 
 // src/funcs/serversGetOutOfBand.ts
 function serversGetOutOfBand(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerOutOfBandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74106,9 +74777,9 @@ var init_serversGetOutOfBand2 = __esm(() => {
 
 // src/funcs/serversList.ts
 function serversList(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServersRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -74135,7 +74806,8 @@ async function $do74(client, request, options) {
     "filter[status]": payload?.["filter[status]"],
     "filter[tags]": payload?.["filter[tags]"],
     "page[number]": payload?.["page[number]"],
-    "page[size]": payload?.["page[size]"]
+    "page[size]": payload?.["page[size]"],
+    "stats[total]": payload?.["stats[total]"]
   });
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -74264,9 +74936,9 @@ Returns a list of all servers belonging to the team.
 
 // src/funcs/serversLock.ts
 function serversLock(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerLockRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74372,9 +75044,9 @@ Locks the server. A locked server cannot be deleted or modified and no actions c
 
 // src/funcs/serversReinstall.ts
 function serversReinstall(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerReinstallRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74482,9 +75154,9 @@ var init_serversReinstall2 = __esm(() => {
 
 // src/funcs/serversRunAction.ts
 function serversRunAction(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerActionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74595,9 +75267,9 @@ Performs an action on a given server:
 
 // src/funcs/serversScheduleDeletion.ts
 function serversScheduleDeletion(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerScheduleDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74703,9 +75375,9 @@ Schedules the server to be removed at the end of the billing cycle.`,
 
 // src/funcs/serversStartOutOfBandConnection.ts
 function serversStartOutOfBandConnection(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerOutOfBandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74810,9 +75482,9 @@ var init_serversStartOutOfBandConnection2 = __esm(() => {
 
 // src/funcs/serversStartRescueMode.ts
 function serversStartRescueMode(client, request, options) {
-  return new APIPromise($do80(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerStartRescueModeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74918,9 +75590,9 @@ Starts rescue mode on a given server.`,
 
 // src/funcs/serversUnlock.ts
 function serversUnlock(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerUnlockRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75026,9 +75698,9 @@ Unlocks the server. A locked server cannot be deleted or modified and no actions
 
 // src/funcs/serversUnscheduleDeletion.ts
 function serversUnscheduleDeletion(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerUnscheduleDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75131,9 +75803,9 @@ Unschedules the server removal at the end of the billing cycle.`,
 
 // src/funcs/serversUpdate.ts
 function serversUpdate(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75238,9 +75910,9 @@ var init_serversUpdate2 = __esm(() => {
 
 // src/funcs/serversUpdateDeployConfig.ts
 function serversUpdateDeployConfig(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateServerDeployConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75345,9 +76017,9 @@ var init_serversUpdateDeployConfig2 = __esm(() => {
 
 // src/funcs/sshKeysCreate.ts
 function sshKeysCreate(client, request, options) {
-  return new APIPromise($do85(client, request, options));
+  return new APIPromise($do86(client, request, options));
 }
-async function $do85(client, request, options) {
+async function $do86(client, request, options) {
   const parsed = safeParse4(request, (value) => PostSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75448,9 +76120,9 @@ Allows you create SSH Keys. These keys can be used to access servers after deplo
 
 // src/funcs/sshKeysDelete.ts
 function sshKeysDelete(client, request, options) {
-  return new APIPromise($do86(client, request, options));
+  return new APIPromise($do87(client, request, options));
 }
-async function $do86(client, request, options) {
+async function $do87(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75554,9 +76226,9 @@ Allows you remove SSH Keys in a project. Remove a SSH Key from the project won't
 
 // src/funcs/sshKeysGet.ts
 function sshKeysGet(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75666,9 +76338,9 @@ List all SSH Keys in the project. These keys can be used to access servers after
 
 // src/funcs/sshKeysList.ts
 function sshKeysList(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectSshKeysRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75782,9 +76454,9 @@ List all SSH Keys in the project. These keys can be used to access servers after
 
 // src/funcs/sshKeysListAll.ts
 function sshKeysListAll(client, request, options) {
-  return new APIPromise($do89(client, request, options));
+  return new APIPromise($do90(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do90(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSshKeysRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75894,9 +76566,9 @@ List all SSH Keys in the project. These keys can be used to access servers after
 
 // src/funcs/sshKeysModifyProjectKey.ts
 function sshKeysModifyProjectKey(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse4(request, (value) => PutProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76007,9 +76679,9 @@ Allow you update SSH Key in a project. These keys can be used to access servers
 
 // src/funcs/sshKeysRemoveFromProject.ts
 function sshKeysRemoveFromProject(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76117,9 +76789,9 @@ Allow you remove SSH Keys in a project. Remove a SSH Key from the project won't
 
 // src/funcs/sshKeysRetrieve.ts
 function sshKeysRetrieve(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76225,9 +76897,9 @@ List all SSH Keys in the project. These keys can be used to access servers after
 
 // src/funcs/sshKeysUpdate.ts
 function sshKeysUpdate(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse4(request, (value) => PutSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76334,9 +77006,9 @@ Allows you update SSH Key in a project. These keys can be used to access servers
 
 // src/funcs/tagsCreate.ts
 function tagsCreate(client, request, options) {
-  return new APIPromise($do94(client, request, options));
+  return new APIPromise($do95(client, request, options));
 }
-async function $do94(client, request, options) {
+async function $do95(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76444,9 +77116,9 @@ Create a Tag in the team.
 
 // src/funcs/tagsDelete.ts
 function tagsDelete(client, request, options) {
-  return new APIPromise($do95(client, request, options));
+  return new APIPromise($do96(client, request, options));
 }
-async function $do95(client, request, options) {
+async function $do96(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76550,9 +77222,9 @@ Update a Tag in the team.
 
 // src/funcs/tagsList.ts
 function tagsList(client, options) {
-  return new APIPromise($do96(client, options));
+  return new APIPromise($do97(client, options));
 }
-async function $do96(client, options) {
+async function $do97(client, options) {
   const path = pathToFunc("/tags")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -76638,9 +77310,9 @@ List all Tags in the team.
 
 // src/funcs/tagsUpdate.ts
 function tagsUpdate(client, request, options) {
-  return new APIPromise($do97(client, request, options));
+  return new APIPromise($do98(client, request, options));
 }
-async function $do97(client, request, options) {
+async function $do98(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76754,9 +77426,9 @@ Update a Tag in the team.
 
 // src/funcs/teamMembersDelete.ts
 function teamMembersDelete(client, request, options) {
-  return new APIPromise($do98(client, request, options));
+  return new APIPromise($do99(client, request, options));
 }
-async function $do98(client, request, options) {
+async function $do99(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyTeamMemberRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76857,9 +77529,9 @@ var init_teamMembersDelete2 = __esm(() => {
 
 // src/funcs/teamMembersPostTeamMembers.ts
 function teamMembersPostTeamMembers(client, request, options) {
-  return new APIPromise($do99(client, request, options));
+  return new APIPromise($do100(client, request, options));
 }
-async function $do99(client, request, options) {
+async function $do100(client, request, options) {
   const parsed = safeParse4(request, (value) => PostTeamMembersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76958,9 +77630,9 @@ var init_teamMembersPostTeamMembers2 = __esm(() => {
 
 // src/funcs/teamsCreate.ts
 function teamsCreate(client, request, options) {
-  return new APIPromise($do100(client, request, options));
+  return new APIPromise($do101(client, request, options));
 }
-async function $do100(client, request, options) {
+async function $do101(client, request, options) {
   const parsed = safeParse4(request, (value) => PostTeamRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77058,9 +77730,9 @@ var init_teamsCreate2 = __esm(() => {
 
 // src/funcs/teamsGet.ts
 function teamsGet(client, options) {
-  return new APIPromise($do101(client, options));
+  return new APIPromise($do102(client, options));
 }
-async function $do101(client, options) {
+async function $do102(client, options) {
   const path = pathToFunc("/team")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -77143,9 +77815,9 @@ var init_teamsGet2 = __esm(() => {
 
 // src/funcs/teamsMembersGetTeamMembers.ts
 function teamsMembersGetTeamMembers(client, request, options) {
-  return new APIPromise($do102(client, request, options));
+  return new APIPromise($do103(client, request, options));
 }
-async function $do102(client, request, options) {
+async function $do103(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTeamMembersRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -77281,9 +77953,9 @@ var init_teamsMembersGetTeamMembers2 = __esm(() => {
 
 // src/funcs/teamsUpdate.ts
 function teamsUpdate(client, request, options) {
-  return new APIPromise($do103(client, request, options));
+  return new APIPromise($do104(client, request, options));
 }
-async function $do103(client, request, options) {
+async function $do104(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchCurrentTeamRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77387,9 +78059,9 @@ var init_teamsUpdate2 = __esm(() => {
 
 // src/funcs/trafficGet.ts
 function trafficGet(client, request, options) {
-  return new APIPromise($do104(client, request, options));
+  return new APIPromise($do105(client, request, options));
 }
-async function $do104(client, request, options) {
+async function $do105(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTrafficConsumptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77494,9 +78166,9 @@ var init_trafficGet2 = __esm(() => {
 
 // src/funcs/trafficGetQuota.ts
 function trafficGetQuota(client, request, options) {
-  return new APIPromise($do105(client, request, options));
+  return new APIPromise($do106(client, request, options));
 }
-async function $do105(client, request, options) {
+async function $do106(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTrafficQuotaRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77598,9 +78270,9 @@ var init_trafficGetQuota2 = __esm(() => {
 
 // src/funcs/userDataCreate.ts
 function userDataCreate(client, request, options) {
-  return new APIPromise($do106(client, request, options));
+  return new APIPromise($do107(client, request, options));
 }
-async function $do106(client, request, options) {
+async function $do107(client, request, options) {
   const parsed = safeParse4(request, (value) => PostProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77708,9 +78380,9 @@ Allows you to create User Data in a project, which can be used to perform custom
 
 // src/funcs/userDataCreateNew.ts
 function userDataCreateNew(client, request, options) {
-  return new APIPromise($do107(client, request, options));
+  return new APIPromise($do108(client, request, options));
 }
-async function $do107(client, request, options) {
+async function $do108(client, request, options) {
   const parsed = safeParse4(request, (value) => PostUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77812,9 +78484,9 @@ Allows you to create User Data in a team, which can be used to perform custom se
 
 // src/funcs/userDataDelete.ts
 function userDataDelete(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+  return new APIPromise($do109(client, request, options));
 }
-async function $do108(client, request, options) {
+async function $do109(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77915,9 +78587,9 @@ var init_userDataDelete2 = __esm(() => {
 
 // src/funcs/userDataDeleteProjectUserData.ts
 function userDataDeleteProjectUserData(client, request, options) {
-  return new APIPromise($do109(client, request, options));
+  return new APIPromise($do110(client, request, options));
 }
-async function $do109(client, request, options) {
+async function $do110(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78025,9 +78697,9 @@ Allow you remove User Data in a project.
 
 // src/funcs/userDataGetProjectUserData.ts
 function userDataGetProjectUserData(client, request, options) {
-  return new APIPromise($do110(client, request, options));
+  return new APIPromise($do111(client, request, options));
 }
-async function $do110(client, request, options) {
+async function $do111(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78142,9 +78814,9 @@ Get User Data in the project. These scripts can be used to configure servers wit
 
 // src/funcs/userDataGetProjectUsersData.ts
 function userDataGetProjectUsersData(client, request, options) {
-  return new APIPromise($do111(client, request, options));
+  return new APIPromise($do112(client, request, options));
 }
-async function $do111(client, request, options) {
+async function $do112(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectUsersDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78255,9 +78927,9 @@ List all Users Data in the project. These scripts can be used to configure serve
 
 // src/funcs/userDataList.ts
 function userDataList(client, request, options) {
-  return new APIPromise($do112(client, request, options));
+  return new APIPromise($do113(client, request, options));
 }
-async function $do112(client, request, options) {
+async function $do113(client, request, options) {
   const parsed = safeParse4(request, (value) => GetUsersDataRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -78400,9 +79072,9 @@ List all Users Data in the project. These scripts can be used to configure serve
 
 // src/funcs/userDataRetrieve.ts
 function userDataRetrieve(client, request, options) {
-  return new APIPromise($do113(client, request, options));
+  return new APIPromise($do114(client, request, options));
 }
-async function $do113(client, request, options) {
+async function $do114(client, request, options) {
   const parsed = safeParse4(request, (value) => GetUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78513,9 +79185,9 @@ Get User Data in the project. These scripts can be used to configure servers wit
 
 // src/funcs/userDataUpdate.ts
 function userDataUpdate(client, request, options) {
-  return new APIPromise($do114(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do114(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78623,9 +79295,9 @@ Allow you update User Data in a team.
 
 // src/funcs/userDataUpdateForProject.ts
 function userDataUpdateForProject(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse4(request, (value) => PutProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78737,9 +79409,9 @@ Allow you update User Data in a project.
 
 // src/funcs/userProfileGet.ts
 function userProfileGet(client, options) {
-  return new APIPromise($do116(client, options));
+  return new APIPromise($do117(client, options));
 }
-async function $do116(client, options) {
+async function $do117(client, options) {
   const path = pathToFunc("/user/profile")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -78825,9 +79497,9 @@ Retrieve the current user profile
 
 // src/funcs/userProfileListTeams.ts
 function userProfileListTeams(client, options) {
-  return new APIPromise($do117(client, options));
+  return new APIPromise($do118(client, options));
 }
-async function $do117(client, options) {
+async function $do118(client, options) {
   const path = pathToFunc("/user/teams")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -78913,9 +79585,9 @@ Returns a list of all teams the user belongs to
 
 // src/funcs/userProfileUpdate.ts
 function userProfileUpdate(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchUserProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79020,18 +79692,18 @@ Update the current user profile
   };
 });
 
-// src/funcs/virtualMachinesCreate.ts
-function virtualMachinesCreate(client, request, options) {
-  return new APIPromise($do119(client, request, options));
+// src/funcs/virtualMachineBackupsCreate.ts
+function virtualMachineBackupsCreate(client, request, options) {
+  return new APIPromise($do120(client, request, options));
 }
-async function $do119(client, request, options) {
-  const parsed = safeParse4(request, (value) => VirtualMachinePayload$outboundSchema.parse(value), "Input validation failed");
+async function $do120(client, request, options) {
+  const parsed = safeParse4(request, (value) => VirtualMachineBackupPayload$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/virtual_machines")();
+  const path = pathToFunc("/virtual_machine_backups")();
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/vnd.api+json"
@@ -79042,7 +79714,7 @@ async function $do119(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create-virtual-machine",
+    operationID: "create-virtual-machine-backup-top-level",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -79073,15 +79745,20 @@ async function $do119(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(201, VirtualMachine$inboundSchema, {
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, VirtualMachineBackup$inboundSchema, {
     ctype: "application/vnd.api+json"
-  }), fail("4XX"), fail("5XX"))(response, req);
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_virtualMachinesCreate = __esm(() => {
+var init_virtualMachineBackupsCreate = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -79089,28 +79766,29 @@ var init_virtualMachinesCreate = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_errors4();
   init_models();
   init_async();
 });
 
-// src/mcp-server/tools/virtualMachinesCreate.ts
-var args112, tool$virtualMachinesCreate;
-var init_virtualMachinesCreate2 = __esm(() => {
-  init_virtualMachinesCreate();
+// src/mcp-server/tools/virtualMachineBackupsCreate.ts
+var args112, tool$virtualMachineBackupsCreate;
+var init_virtualMachineBackupsCreate2 = __esm(() => {
+  init_virtualMachineBackupsCreate();
   init_models();
   init_tools();
   args112 = {
-    request: VirtualMachinePayload$inboundSchema
+    request: VirtualMachineBackupPayload$inboundSchema
   };
-  tool$virtualMachinesCreate = {
-    name: "virtual-machines-create",
-    description: `Create VM
+  tool$virtualMachineBackupsCreate = {
+    name: "virtual-machine-backups-create",
+    description: `Create VM backup (top-level)
 
-Creates a new Virtual Machine.
+Triggers a backup of the Virtual Machine referenced in the body.
 `,
     args: args112,
     tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreate(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await virtualMachineBackupsCreate(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79123,24 +79801,23 @@ Creates a new Virtual Machine.
   };
 });
 
-// src/funcs/virtualMachinesCreateVirtualMachineAction.ts
-function virtualMachinesCreateVirtualMachineAction(client, request, options) {
-  return new APIPromise($do120(client, request, options));
+// src/funcs/virtualMachineBackupsCreateForVirtualMachine.ts
+function virtualMachineBackupsCreateForVirtualMachine(client, request, options) {
+  return new APIPromise($do121(client, request, options));
 }
-async function $do120(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateVirtualMachineActionRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do121(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.RequestBody, { explode: true });
+  const body = null;
   const pathParams = {
     virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/actions")(pathParams);
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/backups")(pathParams);
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "*/*"
+    Accept: "application/vnd.api+json"
   }));
   const secConfig = await extractSecurity(client._options.bearer);
   const securityInput = secConfig == null ? {} : { bearer: secConfig };
@@ -79148,7 +79825,7 @@ async function $do120(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create-virtual-machine-action",
+    operationID: "create-virtual-machine-backup",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -79179,14 +79856,20 @@ async function $do120(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(nil(201, voidType()), fail("4XX"), fail("5XX"))(response, req);
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, VirtualMachineBackup$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_virtualMachinesCreateVirtualMachineAction = __esm(() => {
-  init_v3();
+var init_virtualMachineBackupsCreateForVirtualMachine = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -79194,59 +79877,61 @@ var init_virtualMachinesCreateVirtualMachineAction = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_errors4();
+  init_models();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/virtualMachinesCreateVirtualMachineAction.ts
-var args113, tool$virtualMachinesCreateVirtualMachineAction;
-var init_virtualMachinesCreateVirtualMachineAction2 = __esm(() => {
-  init_virtualMachinesCreateVirtualMachineAction();
+// src/mcp-server/tools/virtualMachineBackupsCreateForVirtualMachine.ts
+var args113, tool$virtualMachineBackupsCreateForVirtualMachine;
+var init_virtualMachineBackupsCreateForVirtualMachine2 = __esm(() => {
+  init_virtualMachineBackupsCreateForVirtualMachine();
   init_operations();
   init_tools();
   args113 = {
-    request: CreateVirtualMachineActionRequest$inboundSchema
+    request: CreateVirtualMachineBackupRequest$inboundSchema
   };
-  tool$virtualMachinesCreateVirtualMachineAction = {
-    name: "virtual-machines-create-virtual-machine-action",
-    description: `Run VM power action
+  tool$virtualMachineBackupsCreateForVirtualMachine = {
+    name: "virtual-machine-backups-create-for-virtual-machine",
+    description: `Create VM backup
 
-Performs a power action on a given virtual machine:
-- \`power_on\` - Starts the virtual machine
-- \`power_off\` - Stops the virtual machine
-- \`reboot\` - Restarts the virtual machine
+Triggers a backup of the given Virtual Machine.
 `,
     args: args113,
     tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreateVirtualMachineAction(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await virtualMachineBackupsCreateForVirtualMachine(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
-function virtualMachinesCreateVirtualMachineNetworkAttachment(client, request, options) {
-  return new APIPromise($do121(client, request, options));
+// src/funcs/virtualMachineBackupsDelete.ts
+function virtualMachineBackupsDelete(client, request, options) {
+  return new APIPromise($do122(client, request, options));
 }
-async function $do121(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do122(client, request, options) {
+  const parsed = safeParse4(request, (value) => DeleteVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.virtual_machine_network_attachment_create_payload, { explode: true });
+  const body = null;
   const pathParams = {
-    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
   };
-  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/network_attachments")(pathParams);
+  const path = pathToFunc("/virtual_machine_backups/{id}")(pathParams);
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/vnd.api+json"
   }));
   const secConfig = await extractSecurity(client._options.bearer);
@@ -79255,7 +79940,7 @@ async function $do121(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create-virtual-machine-network-attachment",
+    operationID: "delete-virtual-machine-backup",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -79264,7 +79949,7 @@ async function $do121(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -79286,13 +79971,20 @@ async function $do121(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(202, CreateVirtualMachineNetworkAttachmentResponse$inboundSchema, { ctype: "application/vnd.api+json" }), fail([403, 404, 422, "4XX"]), fail("5XX"))(response, req);
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(202, VirtualMachineBackup$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, 409, 422, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_virtualMachinesCreateVirtualMachineNetworkAttachment = __esm(() => {
+var init_virtualMachineBackupsDelete = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -79300,28 +79992,30 @@ var init_virtualMachinesCreateVirtualMachineNetworkAttachment = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_errors4();
+  init_models();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
-var args114, tool$virtualMachinesCreateVirtualMachineNetworkAttachment;
-var init_virtualMachinesCreateVirtualMachineNetworkAttachment2 = __esm(() => {
-  init_virtualMachinesCreateVirtualMachineNetworkAttachment();
+// src/mcp-server/tools/virtualMachineBackupsDelete.ts
+var args114, tool$virtualMachineBackupsDelete;
+var init_virtualMachineBackupsDelete2 = __esm(() => {
+  init_virtualMachineBackupsDelete();
   init_operations();
   init_tools();
   args114 = {
-    request: CreateVirtualMachineNetworkAttachmentRequest$inboundSchema
+    request: DeleteVirtualMachineBackupRequest$inboundSchema
   };
-  tool$virtualMachinesCreateVirtualMachineNetworkAttachment = {
-    name: "virtual-machines-create-virtual-machine-network-attachment",
-    description: `Attach a network to a VM
+  tool$virtualMachineBackupsDelete = {
+    name: "virtual-machine-backups-delete",
+    description: `Delete VM backup
 
-Attaches a virtual network (VLAN) to a Virtual Machine. Work runs asynchronously and returns 202 Accepted.
+Archives and deletes a Virtual Machine backup. Work runs asynchronously and returns 202 Accepted. Only \`Ready\` or \`Failed\` backups can be deleted, and not while a restore from the backup is in progress.
 `,
     args: args114,
     tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreateVirtualMachineNetworkAttachment(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await virtualMachineBackupsDelete(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79334,23 +80028,26 @@ Attaches a virtual network (VLAN) to a Virtual Machine. Work runs asynchronously
   };
 });
 
-// src/funcs/virtualMachinesDelete.ts
-function virtualMachinesDelete(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+// src/funcs/virtualMachineBackupsGet.ts
+function virtualMachineBackupsGet(client, request, options) {
+  return new APIPromise($do123(client, request, options));
 }
-async function $do122(client, request, options) {
-  const parsed = safeParse4(request, (value) => DestroyVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do123(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
   };
-  const path = pathToFunc("/virtual_machines/{virtual_machine_id}")(pathParams);
+  const path = pathToFunc("/virtual_machine_backups/{id}")(pathParams);
   const headers = new Headers(compactMap({
-    Accept: "*/*"
+    Accept: "application/vnd.api+json"
   }));
   const secConfig = await extractSecurity(client._options.bearer);
   const securityInput = secConfig == null ? {} : { bearer: secConfig };
@@ -79358,7 +80055,7 @@ async function $do122(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "destroy-virtual-machine",
+    operationID: "get-virtual-machine-backup",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -79367,7 +80064,7 @@ async function $do122(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -79389,8 +80086,1302 @@ async function $do122(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(nil(204, voidType()), fail("4XX"), fail("5XX"))(response, req);
-  if (!result.ok) {
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineBackup$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineBackupsGet = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineBackupsGet.ts
+var args115, tool$virtualMachineBackupsGet;
+var init_virtualMachineBackupsGet2 = __esm(() => {
+  init_virtualMachineBackupsGet();
+  init_operations();
+  init_tools();
+  args115 = {
+    request: GetVirtualMachineBackupRequest$inboundSchema
+  };
+  tool$virtualMachineBackupsGet = {
+    name: "virtual-machine-backups-get",
+    description: `Get VM backup`,
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsGet(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineBackupsList.ts
+function virtualMachineBackupsList(client, options) {
+  return new APIPromise($do124(client, options));
+}
+async function $do124(client, options) {
+  const path = pathToFunc("/virtual_machine_backups")();
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list-virtual-machine-backups",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineBackups$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineBackupsList = __esm(() => {
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineBackupsList.ts
+var tool$virtualMachineBackupsList;
+var init_virtualMachineBackupsList2 = __esm(() => {
+  init_virtualMachineBackupsList();
+  init_tools();
+  tool$virtualMachineBackupsList = {
+    name: "virtual-machine-backups-list",
+    description: `List all VM backups
+
+Lists every backup that belongs to the authenticated team.
+`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsList(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineBackupsListForVirtualMachine.ts
+function virtualMachineBackupsListForVirtualMachine(client, request, options) {
+  return new APIPromise($do125(client, request, options));
+}
+async function $do125(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListVirtualMachineScopedBackupsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/backups")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list-virtual-machine-scoped-backups",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineBackups$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineBackupsListForVirtualMachine = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineBackupsListForVirtualMachine.ts
+var args116, tool$virtualMachineBackupsListForVirtualMachine;
+var init_virtualMachineBackupsListForVirtualMachine2 = __esm(() => {
+  init_virtualMachineBackupsListForVirtualMachine();
+  init_operations();
+  init_tools();
+  args116 = {
+    request: ListVirtualMachineScopedBackupsRequest$inboundSchema
+  };
+  tool$virtualMachineBackupsListForVirtualMachine = {
+    name: "virtual-machine-backups-list-for-virtual-machine",
+    description: `List a VM's backups
+
+Lists the backups of the given Virtual Machine.
+`,
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsListForVirtualMachine(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresCreate.ts
+function virtualMachineRestoresCreate(client, request, options) {
+  return new APIPromise($do126(client, request, options));
+}
+async function $do126(client, request, options) {
+  const parsed = safeParse4(request, (value) => VirtualMachineRestorePayload$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/virtual_machine_restores")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create-virtual-machine-restore-flat",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, VirtualMachineRestore$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, 409, 422, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresCreate = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresCreate.ts
+var args117, tool$virtualMachineRestoresCreate;
+var init_virtualMachineRestoresCreate2 = __esm(() => {
+  init_virtualMachineRestoresCreate();
+  init_models();
+  init_tools();
+  args117 = {
+    request: VirtualMachineRestorePayload$inboundSchema
+  };
+  tool$virtualMachineRestoresCreate = {
+    name: "virtual-machine-restores-create",
+    description: `Create VM restore (flat)
+
+Restores the backup referenced in the body into a new Virtual Machine. Optionally accepts a \`name\` for the restored VM and a target \`site\` slug to restore into another region.
+`,
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresCreate(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresCreateForVirtualMachineBackup.ts
+function virtualMachineRestoresCreateForVirtualMachineBackup(client, request, options) {
+  return new APIPromise($do127(client, request, options));
+}
+async function $do127(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateVirtualMachineRestoreRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.virtual_machine_restore_payload, {
+    explode: true
+  });
+  const pathParams = {
+    backup_id: encodeSimple("backup_id", payload.backup_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/backups/{backup_id}/restores")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create-virtual-machine-restore",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, VirtualMachineRestore$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, 409, 422, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresCreateForVirtualMachineBackup = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresCreateForVirtualMachineBackup.ts
+var args118, tool$virtualMachineRestoresCreateForVirtualMachineBackup;
+var init_virtualMachineRestoresCreateForVirtualMachineBackup2 = __esm(() => {
+  init_virtualMachineRestoresCreateForVirtualMachineBackup();
+  init_operations();
+  init_tools();
+  args118 = {
+    request: CreateVirtualMachineRestoreRequest$inboundSchema
+  };
+  tool$virtualMachineRestoresCreateForVirtualMachineBackup = {
+    name: "virtual-machine-restores-create-for-virtual-machine-backup",
+    description: `Create VM restore
+
+Restores a backup into a new Virtual Machine. Optionally accepts a \`name\` for the restored VM and a target \`site\` slug to restore into another region.
+`,
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresCreateForVirtualMachineBackup(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresGet.ts
+function virtualMachineRestoresGet(client, request, options) {
+  return new APIPromise($do128(client, request, options));
+}
+async function $do128(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetVirtualMachineRestoreRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/virtual_machine_restores/{id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "get-virtual-machine-restore",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineRestore$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresGet = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresGet.ts
+var args119, tool$virtualMachineRestoresGet;
+var init_virtualMachineRestoresGet2 = __esm(() => {
+  init_virtualMachineRestoresGet();
+  init_operations();
+  init_tools();
+  args119 = {
+    request: GetVirtualMachineRestoreRequest$inboundSchema
+  };
+  tool$virtualMachineRestoresGet = {
+    name: "virtual-machine-restores-get",
+    description: `Get VM restore`,
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresGet(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresList.ts
+function virtualMachineRestoresList(client, options) {
+  return new APIPromise($do129(client, options));
+}
+async function $do129(client, options) {
+  const path = pathToFunc("/virtual_machine_restores")();
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list-virtual-machine-restores",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineRestores$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresList = __esm(() => {
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresList.ts
+var tool$virtualMachineRestoresList;
+var init_virtualMachineRestoresList2 = __esm(() => {
+  init_virtualMachineRestoresList();
+  init_tools();
+  tool$virtualMachineRestoresList = {
+    name: "virtual-machine-restores-list",
+    description: `List all VM restores
+
+Lists every restore that belongs to the authenticated team.
+`,
+    tool: async (client, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresList(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresListForBackup.ts
+function virtualMachineRestoresListForBackup(client, request, options) {
+  return new APIPromise($do130(client, request, options));
+}
+async function $do130(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListBackupRestoresRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    backup_id: encodeSimple("backup_id", payload.backup_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/virtual_machine_backups/{backup_id}/restores")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list-backup-restores",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineRestores$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresListForBackup = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresListForBackup.ts
+var args120, tool$virtualMachineRestoresListForBackup;
+var init_virtualMachineRestoresListForBackup2 = __esm(() => {
+  init_virtualMachineRestoresListForBackup();
+  init_operations();
+  init_tools();
+  args120 = {
+    request: ListBackupRestoresRequest$inboundSchema
+  };
+  tool$virtualMachineRestoresListForBackup = {
+    name: "virtual-machine-restores-list-for-backup",
+    description: `List a backup's restores (top-level backup path)
+
+Lists the restores created from the given backup, reached via the top-level backup path.
+`,
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresListForBackup(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachineRestoresListForVirtualMachineBackup.ts
+function virtualMachineRestoresListForVirtualMachineBackup(client, request, options) {
+  return new APIPromise($do131(client, request, options));
+}
+async function $do131(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListVirtualMachineScopedRestoresRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    backup_id: encodeSimple("backup_id", payload.backup_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/backups/{backup_id}/restores")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list-virtual-machine-scoped-restores",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, VirtualMachineRestores$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr(403, ErrorObject$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail([404, "4XX"]), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachineRestoresListForVirtualMachineBackup = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachineRestoresListForVirtualMachineBackup.ts
+var args121, tool$virtualMachineRestoresListForVirtualMachineBackup;
+var init_virtualMachineRestoresListForVirtualMachineBackup2 = __esm(() => {
+  init_virtualMachineRestoresListForVirtualMachineBackup();
+  init_operations();
+  init_tools();
+  args121 = {
+    request: ListVirtualMachineScopedRestoresRequest$inboundSchema
+  };
+  tool$virtualMachineRestoresListForVirtualMachineBackup = {
+    name: "virtual-machine-restores-list-for-virtual-machine-backup",
+    description: `List a backup's restores
+
+Lists the restores created from the given backup.
+`,
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresListForVirtualMachineBackup(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachinesCreate.ts
+function virtualMachinesCreate(client, request, options) {
+  return new APIPromise($do132(client, request, options));
+}
+async function $do132(client, request, options) {
+  const parsed = safeParse4(request, (value) => VirtualMachinePayload$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/virtual_machines")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create-virtual-machine",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(201, VirtualMachine$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachinesCreate = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_models();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachinesCreate.ts
+var args122, tool$virtualMachinesCreate;
+var init_virtualMachinesCreate2 = __esm(() => {
+  init_virtualMachinesCreate();
+  init_models();
+  init_tools();
+  args122 = {
+    request: VirtualMachinePayload$inboundSchema
+  };
+  tool$virtualMachinesCreate = {
+    name: "virtual-machines-create",
+    description: `Create VM
+
+Creates a new Virtual Machine.
+`,
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreate(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachinesCreateVirtualMachineAction.ts
+function virtualMachinesCreateVirtualMachineAction(client, request, options) {
+  return new APIPromise($do133(client, request, options));
+}
+async function $do133(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateVirtualMachineActionRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
+  const pathParams = {
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/actions")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "*/*"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create-virtual-machine-action",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(nil(201, voidType()), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachinesCreateVirtualMachineAction = __esm(() => {
+  init_v3();
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachinesCreateVirtualMachineAction.ts
+var args123, tool$virtualMachinesCreateVirtualMachineAction;
+var init_virtualMachinesCreateVirtualMachineAction2 = __esm(() => {
+  init_virtualMachinesCreateVirtualMachineAction();
+  init_operations();
+  init_tools();
+  args123 = {
+    request: CreateVirtualMachineActionRequest$inboundSchema
+  };
+  tool$virtualMachinesCreateVirtualMachineAction = {
+    name: "virtual-machines-create-virtual-machine-action",
+    description: `Run VM power action
+
+Performs a power action on a given virtual machine:
+- \`power_on\` - Starts the virtual machine
+- \`power_off\` - Stops the virtual machine
+- \`reboot\` - Restarts the virtual machine
+`,
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreateVirtualMachineAction(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(undefined, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
+function virtualMachinesCreateVirtualMachineNetworkAttachment(client, request, options) {
+  return new APIPromise($do134(client, request, options));
+}
+async function $do134(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.virtual_machine_network_attachment_create_payload, { explode: true });
+  const pathParams = {
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}/network_attachments")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/vnd.api+json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create-virtual-machine-network-attachment",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(202, CreateVirtualMachineNetworkAttachmentResponse$inboundSchema, { ctype: "application/vnd.api+json" }), fail([403, 404, 422, "4XX"]), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_virtualMachinesCreateVirtualMachineNetworkAttachment = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
+var args124, tool$virtualMachinesCreateVirtualMachineNetworkAttachment;
+var init_virtualMachinesCreateVirtualMachineNetworkAttachment2 = __esm(() => {
+  init_virtualMachinesCreateVirtualMachineNetworkAttachment();
+  init_operations();
+  init_tools();
+  args124 = {
+    request: CreateVirtualMachineNetworkAttachmentRequest$inboundSchema
+  };
+  tool$virtualMachinesCreateVirtualMachineNetworkAttachment = {
+    name: "virtual-machines-create-virtual-machine-network-attachment",
+    description: `Attach a network to a VM
+
+Attaches a virtual network (VLAN) to a Virtual Machine. Work runs asynchronously and returns 202 Accepted.
+`,
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreateVirtualMachineNetworkAttachment(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/virtualMachinesDelete.ts
+function virtualMachinesDelete(client, request, options) {
+  return new APIPromise($do135(client, request, options));
+}
+async function $do135(client, request, options) {
+  const parsed = safeParse4(request, (value) => DestroyVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/virtual_machines/{virtual_machine_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "*/*"
+  }));
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "destroy-virtual-machine",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(nil(204, voidType()), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
@@ -79409,12 +81400,12 @@ var init_virtualMachinesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesDelete.ts
-var args115, tool$virtualMachinesDelete;
+var args125, tool$virtualMachinesDelete;
 var init_virtualMachinesDelete2 = __esm(() => {
   init_virtualMachinesDelete();
   init_operations();
   init_tools();
-  args115 = {
+  args125 = {
     request: DestroyVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesDelete = {
@@ -79423,9 +81414,9 @@ var init_virtualMachinesDelete2 = __esm(() => {
 
 Destroys a Virtual Machine.
 `,
-    args: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await virtualMachinesDelete(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await virtualMachinesDelete(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79439,9 +81430,9 @@ Destroys a Virtual Machine.
 
 // src/funcs/virtualMachinesDestroyVirtualMachineNetworkAttachment.ts
 function virtualMachinesDestroyVirtualMachineNetworkAttachment(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79515,12 +81506,12 @@ var init_virtualMachinesDestroyVirtualMachineNetworkAttachment = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesDestroyVirtualMachineNetworkAttachment.ts
-var args116, tool$virtualMachinesDestroyVirtualMachineNetworkAttachment;
+var args126, tool$virtualMachinesDestroyVirtualMachineNetworkAttachment;
 var init_virtualMachinesDestroyVirtualMachineNetworkAttachment2 = __esm(() => {
   init_virtualMachinesDestroyVirtualMachineNetworkAttachment();
   init_operations();
   init_tools();
-  args116 = {
+  args126 = {
     request: DestroyVirtualMachineNetworkAttachmentRequest$inboundSchema
   };
   tool$virtualMachinesDestroyVirtualMachineNetworkAttachment = {
@@ -79529,9 +81520,9 @@ var init_virtualMachinesDestroyVirtualMachineNetworkAttachment2 = __esm(() => {
 
 Detaches a virtual network (VLAN) from a Virtual Machine. Work runs asynchronously and returns 202 Accepted.
 `,
-    args: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await virtualMachinesDestroyVirtualMachineNetworkAttachment(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await virtualMachinesDestroyVirtualMachineNetworkAttachment(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79546,9 +81537,9 @@ Detaches a virtual network (VLAN) from a Virtual Machine. Work runs asynchronous
 
 // src/funcs/virtualMachinesGet.ts
 function virtualMachinesGet(client, request, options) {
-  return new APIPromise($do124(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse4(request, (value) => ShowVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79559,6 +81550,9 @@ async function $do124(client, request, options) {
     virtual_machine_id: encodeSimple("virtual_machine_id", payload.virtual_machine_id, { explode: false, charEncoding: "percent" })
   };
   const path = pathToFunc("/virtual_machines/{virtual_machine_id}")(pathParams);
+  const query = encodeFormQuery({
+    "extra_fields[virtual_machines]": payload["extra_fields[virtual_machines]"]
+  });
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
   }));
@@ -79581,6 +81575,7 @@ async function $do124(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -79621,12 +81616,12 @@ var init_virtualMachinesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesGet.ts
-var args117, tool$virtualMachinesGet;
+var args127, tool$virtualMachinesGet;
 var init_virtualMachinesGet2 = __esm(() => {
   init_virtualMachinesGet();
   init_operations();
   init_tools();
-  args117 = {
+  args127 = {
     request: ShowVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesGet = {
@@ -79635,9 +81630,9 @@ var init_virtualMachinesGet2 = __esm(() => {
 
 Show a Virtual Machine.
 `,
-    args: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await virtualMachinesGet(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await virtualMachinesGet(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79652,9 +81647,9 @@ Show a Virtual Machine.
 
 // src/funcs/virtualMachinesList.ts
 function virtualMachinesList(client, request, options) {
-  return new APIPromise($do125(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse4(request, (value) => IndexVirtualMachineRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79730,12 +81725,12 @@ var init_virtualMachinesList = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesList.ts
-var args118, tool$virtualMachinesList;
+var args128, tool$virtualMachinesList;
 var init_virtualMachinesList2 = __esm(() => {
   init_virtualMachinesList();
   init_operations();
   init_tools();
-  args118 = {
+  args128 = {
     request: IndexVirtualMachineRequest$inboundSchema.optional()
   };
   tool$virtualMachinesList = {
@@ -79744,9 +81739,9 @@ var init_virtualMachinesList2 = __esm(() => {
 
 Show all Team's Virtual Machines.
 `,
-    args: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await virtualMachinesList(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await virtualMachinesList(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79761,9 +81756,9 @@ Show all Team's Virtual Machines.
 
 // src/funcs/virtualMachinesListVirtualMachineNetworkAttachments.ts
 function virtualMachinesListVirtualMachineNetworkAttachments(client, request, options) {
-  return new APIPromise($do126(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVirtualMachineNetworkAttachmentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79836,12 +81831,12 @@ var init_virtualMachinesListVirtualMachineNetworkAttachments = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesListVirtualMachineNetworkAttachments.ts
-var args119, tool$virtualMachinesListVirtualMachineNetworkAttachments;
+var args129, tool$virtualMachinesListVirtualMachineNetworkAttachments;
 var init_virtualMachinesListVirtualMachineNetworkAttachments2 = __esm(() => {
   init_virtualMachinesListVirtualMachineNetworkAttachments();
   init_operations();
   init_tools();
-  args119 = {
+  args129 = {
     request: ListVirtualMachineNetworkAttachmentsRequest$inboundSchema
   };
   tool$virtualMachinesListVirtualMachineNetworkAttachments = {
@@ -79850,9 +81845,9 @@ var init_virtualMachinesListVirtualMachineNetworkAttachments2 = __esm(() => {
 
 Lists the secondary network attachments currently configured for a Virtual Machine.
 `,
-    args: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await virtualMachinesListVirtualMachineNetworkAttachments(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await virtualMachinesListVirtualMachineNetworkAttachments(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79867,9 +81862,9 @@ Lists the secondary network attachments currently configured for a Virtual Machi
 
 // src/funcs/virtualMachinesShowVirtualMachineMetrics.ts
 function virtualMachinesShowVirtualMachineMetrics(client, request, options) {
-  return new APIPromise($do127(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do127(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse4(request, (value) => ShowVirtualMachineMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79948,12 +81943,12 @@ var init_virtualMachinesShowVirtualMachineMetrics = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesShowVirtualMachineMetrics.ts
-var args120, tool$virtualMachinesShowVirtualMachineMetrics;
+var args130, tool$virtualMachinesShowVirtualMachineMetrics;
 var init_virtualMachinesShowVirtualMachineMetrics2 = __esm(() => {
   init_virtualMachinesShowVirtualMachineMetrics();
   init_operations();
   init_tools();
-  args120 = {
+  args130 = {
     request: ShowVirtualMachineMetricsRequest$inboundSchema
   };
   tool$virtualMachinesShowVirtualMachineMetrics = {
@@ -79961,9 +81956,9 @@ var init_virtualMachinesShowVirtualMachineMetrics2 = __esm(() => {
     description: `Retrieve VM metrics
 
 Retrieve a time series for a single metric of a Virtual Machine.`,
-    args: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await virtualMachinesShowVirtualMachineMetrics(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await virtualMachinesShowVirtualMachineMetrics(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79978,9 +81973,9 @@ Retrieve a time series for a single metric of a Virtual Machine.`,
 
 // src/funcs/virtualMachinesUpdateVirtualMachine.ts
 function virtualMachinesUpdateVirtualMachine(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80034,9 +82029,9 @@ async function $do128(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, VirtualMachine$inboundSchema, {
+  const [result] = await match(json([200, 202], VirtualMachine$inboundSchema, {
     ctype: "application/vnd.api+json"
-  }), fail([404, 422, "4XX"]), fail("5XX"))(response, req);
+  }), fail([404, 409, 422, "4XX"]), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -80056,12 +82051,12 @@ var init_virtualMachinesUpdateVirtualMachine = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesUpdateVirtualMachine.ts
-var args121, tool$virtualMachinesUpdateVirtualMachine;
+var args131, tool$virtualMachinesUpdateVirtualMachine;
 var init_virtualMachinesUpdateVirtualMachine2 = __esm(() => {
   init_virtualMachinesUpdateVirtualMachine();
   init_operations();
   init_tools();
-  args121 = {
+  args131 = {
     request: UpdateVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesUpdateVirtualMachine = {
@@ -80070,9 +82065,9 @@ var init_virtualMachinesUpdateVirtualMachine2 = __esm(() => {
 
 Updates a Virtual Machine's display name (hostname).
 `,
-    args: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await virtualMachinesUpdateVirtualMachine(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await virtualMachinesUpdateVirtualMachine(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80087,9 +82082,9 @@ Updates a Virtual Machine's display name (hostname).
 
 // src/funcs/virtualNetworksDelete.ts
 function virtualNetworksDelete(client, request, options) {
-  return new APIPromise($do129(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do129(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80163,12 +82158,12 @@ var init_virtualNetworksDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualNetworksDelete.ts
-var args122, tool$virtualNetworksDelete;
+var args132, tool$virtualNetworksDelete;
 var init_virtualNetworksDelete2 = __esm(() => {
   init_virtualNetworksDelete();
   init_operations();
   init_tools();
-  args122 = {
+  args132 = {
     request: DestroyVirtualNetworkRequest$inboundSchema
   };
   tool$virtualNetworksDelete = {
@@ -80177,9 +82172,9 @@ var init_virtualNetworksDelete2 = __esm(() => {
 
 Delete virtual network
 `,
-    args: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await virtualNetworksDelete(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await virtualNetworksDelete(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80193,9 +82188,9 @@ Delete virtual network
 
 // src/funcs/vpnSessionsCreate.ts
 function vpnSessionsCreate(client, request, options) {
-  return new APIPromise($do130(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do130(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse4(request, (value) => PostVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80266,12 +82261,12 @@ var init_vpnSessionsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsCreate.ts
-var args123, tool$vpnSessionsCreate;
+var args133, tool$vpnSessionsCreate;
 var init_vpnSessionsCreate2 = __esm(() => {
   init_vpnSessionsCreate();
   init_operations();
   init_tools();
-  args123 = {
+  args133 = {
     request: PostVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsCreate = {
@@ -80281,9 +82276,9 @@ var init_vpnSessionsCreate2 = __esm(() => {
 Creates a new VPN Session.
 \`NOTE:\` The VPN credentials are only listed ONCE upon creation. They can however be refreshed or deleted.
 `,
-    args: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await vpnSessionsCreate(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await vpnSessionsCreate(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80298,9 +82293,9 @@ Creates a new VPN Session.
 
 // src/funcs/vpnSessionsDelete.ts
 function vpnSessionsDelete(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80374,12 +82369,12 @@ var init_vpnSessionsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsDelete.ts
-var args124, tool$vpnSessionsDelete;
+var args134, tool$vpnSessionsDelete;
 var init_vpnSessionsDelete2 = __esm(() => {
   init_vpnSessionsDelete();
   init_operations();
   init_tools();
-  args124 = {
+  args134 = {
     request: DeleteVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsDelete = {
@@ -80388,9 +82383,9 @@ var init_vpnSessionsDelete2 = __esm(() => {
 
 Deletes an existing VPN Session.
 `,
-    args: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await vpnSessionsDelete(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await vpnSessionsDelete(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80404,9 +82399,9 @@ Deletes an existing VPN Session.
 
 // src/funcs/vpnSessionsList.ts
 function vpnSessionsList(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do145(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do145(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVpnSessionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80479,20 +82474,20 @@ var init_vpnSessionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsList.ts
-var args125, tool$vpnSessionsList;
+var args135, tool$vpnSessionsList;
 var init_vpnSessionsList2 = __esm(() => {
   init_vpnSessionsList();
   init_operations();
   init_tools();
-  args125 = {
+  args135 = {
     request: GetVpnSessionsRequest$inboundSchema.optional()
   };
   tool$vpnSessionsList = {
     name: "vpn-sessions-list",
     description: `List VPN sessions`,
-    args: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await vpnSessionsList(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await vpnSessionsList(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80507,9 +82502,9 @@ var init_vpnSessionsList2 = __esm(() => {
 
 // src/funcs/vpnSessionsRefreshPassword.ts
 function vpnSessionsRefreshPassword(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse4(request, (value) => PutVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80585,12 +82580,12 @@ var init_vpnSessionsRefreshPassword = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsRefreshPassword.ts
-var args126, tool$vpnSessionsRefreshPassword;
+var args136, tool$vpnSessionsRefreshPassword;
 var init_vpnSessionsRefreshPassword2 = __esm(() => {
   init_vpnSessionsRefreshPassword();
   init_operations();
   init_tools();
-  args126 = {
+  args136 = {
     request: PutVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsRefreshPassword = {
@@ -80599,9 +82594,9 @@ var init_vpnSessionsRefreshPassword2 = __esm(() => {
 
 Refreshing an existing VPN Session will create new credentials for that session
 `,
-    args: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await vpnSessionsRefreshPassword(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await vpnSessionsRefreshPassword(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80618,7 +82613,7 @@ Refreshing an existing VPN Session will create new credentials for that session
 function createMCPServer(deps) {
   const server2 = new McpServer({
     name: "Latitudesh",
-    version: "0.6.3"
+    version: "0.6.4"
   });
   const client = new LatitudeshCore({
     bearer: deps.bearer,
@@ -80673,6 +82668,7 @@ function createMCPServer(deps) {
   tool(tool$plansGetBandwidth);
   tool(tool$plansUpdateBandwidth);
   tool(tool$plansListStorage);
+  tool(tool$plansGetManagedDatabasePlans);
   tool(tool$projectsList);
   tool(tool$projectsCreate);
   tool(tool$projectsUpdate);
@@ -80750,6 +82746,18 @@ function createMCPServer(deps) {
   tool(tool$virtualMachinesListVirtualMachineNetworkAttachments);
   tool(tool$virtualMachinesCreateVirtualMachineNetworkAttachment);
   tool(tool$virtualMachinesDestroyVirtualMachineNetworkAttachment);
+  tool(tool$virtualMachineBackupsListForVirtualMachine);
+  tool(tool$virtualMachineBackupsCreateForVirtualMachine);
+  tool(tool$virtualMachineBackupsList);
+  tool(tool$virtualMachineBackupsCreate);
+  tool(tool$virtualMachineBackupsGet);
+  tool(tool$virtualMachineBackupsDelete);
+  tool(tool$virtualMachineRestoresListForVirtualMachineBackup);
+  tool(tool$virtualMachineRestoresCreateForVirtualMachineBackup);
+  tool(tool$virtualMachineRestoresListForBackup);
+  tool(tool$virtualMachineRestoresList);
+  tool(tool$virtualMachineRestoresCreate);
+  tool(tool$virtualMachineRestoresGet);
   tool(tool$privateNetworksList);
   tool(tool$privateNetworksCreate);
   tool(tool$privateNetworksUpdate);
@@ -80819,6 +82827,7 @@ var init_server4 = __esm(() => {
   init_operatingSystemsListPlans2();
   init_plansGet2();
   init_plansGetBandwidth2();
+  init_plansGetManagedDatabasePlans2();
   init_plansList2();
   init_plansListStorage2();
   init_plansUpdateBandwidth2();
@@ -80891,6 +82900,18 @@ var init_server4 = __esm(() => {
   init_userProfileGet2();
   init_userProfileListTeams2();
   init_userProfileUpdate2();
+  init_virtualMachineBackupsCreate2();
+  init_virtualMachineBackupsCreateForVirtualMachine2();
+  init_virtualMachineBackupsDelete2();
+  init_virtualMachineBackupsGet2();
+  init_virtualMachineBackupsList2();
+  init_virtualMachineBackupsListForVirtualMachine2();
+  init_virtualMachineRestoresCreate2();
+  init_virtualMachineRestoresCreateForVirtualMachineBackup2();
+  init_virtualMachineRestoresGet2();
+  init_virtualMachineRestoresList2();
+  init_virtualMachineRestoresListForBackup2();
+  init_virtualMachineRestoresListForVirtualMachineBackup2();
   init_virtualMachinesCreate2();
   init_virtualMachinesCreateVirtualMachineAction2();
   init_virtualMachinesCreateVirtualMachineNetworkAttachment2();
@@ -82109,7 +84130,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.6.3"
+    currentVersion: "0.6.4"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -82117,5 +84138,5 @@ export {
   app
 };
 
-//# debugId=FF1C85F11C06E53C64756E2164756E21
+//# debugId=9DD8B5EDD4254C3E64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map