latitudesh-typescript-sdk 0.8.6 → 0.8.7

package/bin/mcp-server.js

@@ -53149,9 +53149,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2023-06-01",
-    sdkVersion: "0.8.6",
-    genVersion: "2.926.8",
-    userAgent: "speakeasy-sdk/typescript 0.8.6 2.926.8 2023-06-01 latitudesh-typescript-sdk"
+    sdkVersion: "0.8.7",
+    genVersion: "2.928.0",
+    userAgent: "speakeasy-sdk/typescript 0.8.7 2.928.0 2023-06-01 latitudesh-typescript-sdk"
   };
 });
 
@@ -55695,6 +55695,57 @@ var init_createkubernetescluster = __esm(() => {
   });
 });
 
+// src/models/createprefix.ts
+var CreatePrefixType, CreatePrefixSize, CreatePrefixType$inboundSchema, CreatePrefixType$outboundSchema, CreatePrefixSize$inboundSchema, CreatePrefixSize$outboundSchema, CreatePrefixAttributes$inboundSchema, CreatePrefixAttributes$outboundSchema, CreatePrefixData$inboundSchema, CreatePrefixData$outboundSchema, CreatePrefix$inboundSchema, CreatePrefix$outboundSchema;
+var init_createprefix = __esm(() => {
+  init_v3();
+  init_primitives();
+  CreatePrefixType = {
+    Prefixes: "prefixes"
+  };
+  CreatePrefixSize = {
+    TwentySix: 26,
+    TwentySeven: 27,
+    TwentyEight: 28
+  };
+  CreatePrefixType$inboundSchema = nativeEnumType(CreatePrefixType);
+  CreatePrefixType$outboundSchema = CreatePrefixType$inboundSchema;
+  CreatePrefixSize$inboundSchema = nativeEnumType(CreatePrefixSize);
+  CreatePrefixSize$outboundSchema = CreatePrefixSize$inboundSchema;
+  CreatePrefixAttributes$inboundSchema = objectType({
+    project_id: stringType(),
+    site: stringType(),
+    size: CreatePrefixSize$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      project_id: "projectId"
+    });
+  });
+  CreatePrefixAttributes$outboundSchema = objectType({
+    projectId: stringType(),
+    site: stringType(),
+    size: CreatePrefixSize$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      projectId: "project_id"
+    });
+  });
+  CreatePrefixData$inboundSchema = objectType({
+    type: CreatePrefixType$inboundSchema,
+    attributes: lazyType(() => CreatePrefixAttributes$inboundSchema).optional()
+  });
+  CreatePrefixData$outboundSchema = objectType({
+    type: CreatePrefixType$outboundSchema,
+    attributes: lazyType(() => CreatePrefixAttributes$outboundSchema).optional()
+  });
+  CreatePrefix$inboundSchema = objectType({
+    data: lazyType(() => CreatePrefixData$inboundSchema)
+  });
+  CreatePrefix$outboundSchema = objectType({
+    data: lazyType(() => CreatePrefixData$outboundSchema)
+  });
+});
+
 // src/models/teaminclude.ts
 var Currency$inboundSchema, Currency$outboundSchema, TeamIncludeLimits$inboundSchema, TeamIncludeLimits$outboundSchema, TeamInclude$inboundSchema, TeamInclude$outboundSchema;
 var init_teaminclude = __esm(() => {
@@ -55726,6 +55777,7 @@ var init_teaminclude = __esm(() => {
     virtual_machine: nullableType(numberType().int()).optional(),
     virtual_machine_gpu: nullableType(numberType().int()).optional(),
     elastic_ip: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtual_network: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -55747,6 +55799,7 @@ var init_teaminclude = __esm(() => {
     virtualMachine: nullableType(numberType().int()).optional(),
     virtualMachineGpu: nullableType(numberType().int()).optional(),
     elasticIp: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtualNetwork: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -57609,7 +57662,7 @@ var init_membership = __esm(() => {
 });
 
 // src/models/objectstoragedata.ts
-var ObjectStorageDataType, StorageClass, RetentionMode, ObjectStorageDataType$inboundSchema, ObjectStorageDataType$outboundSchema, StorageClass$inboundSchema, StorageClass$outboundSchema, RetentionMode$inboundSchema, RetentionMode$outboundSchema, ObjectStorageDataRegion$inboundSchema, ObjectStorageDataRegion$outboundSchema, ObjectStorageDataAttributes$inboundSchema, ObjectStorageDataAttributes$outboundSchema, ObjectStorageData$inboundSchema, ObjectStorageData$outboundSchema;
+var ObjectStorageDataType, StorageClass, RetentionMode, ObjectStorageDataType$inboundSchema, ObjectStorageDataType$outboundSchema, StorageClass$inboundSchema, StorageClass$outboundSchema, RetentionMode$inboundSchema, RetentionMode$outboundSchema, ObjectStorageDataRegion$inboundSchema, ObjectStorageDataRegion$outboundSchema, ObjectStorageDataCredentials$inboundSchema, ObjectStorageDataCredentials$outboundSchema, ObjectStorageDataAttributes$inboundSchema, ObjectStorageDataAttributes$outboundSchema, ObjectStorageData$inboundSchema, ObjectStorageData$outboundSchema;
 var init_objectstoragedata = __esm(() => {
   init_v3();
   init_primitives();
@@ -57643,6 +57696,20 @@ var init_objectstoragedata = __esm(() => {
     city: stringType().optional(),
     country: nullableType(stringType()).optional()
   });
+  ObjectStorageDataCredentials$inboundSchema = objectType({
+    access_key: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      access_key: "accessKey"
+    });
+  });
+  ObjectStorageDataCredentials$outboundSchema = objectType({
+    accessKey: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      accessKey: "access_key"
+    });
+  });
   ObjectStorageDataAttributes$inboundSchema = objectType({
     name: stringType().optional(),
     storage_type: stringType().optional(),
@@ -57650,14 +57717,13 @@ var init_objectstoragedata = __esm(() => {
     created_at: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
     bucket_name: stringType().optional(),
     endpoint: stringType().optional(),
-    access_key: nullableType(stringType()).optional(),
-    secret_key: nullableType(stringType()).optional(),
     versioning: nullableType(booleanType()).optional(),
     locking: nullableType(booleanType()).optional(),
     retention_mode: nullableType(RetentionMode$inboundSchema).optional(),
     retention_period: nullableType(numberType().int()).optional(),
     source: stringType().optional(),
     region: nullableType(lazyType(() => ObjectStorageDataRegion$inboundSchema)).optional(),
+    credentials: nullableType(lazyType(() => ObjectStorageDataCredentials$inboundSchema)).optional(),
     project: ProjectInclude$inboundSchema.optional(),
     team: TeamInclude$inboundSchema.optional()
   }).transform((v2) => {
@@ -57666,8 +57732,6 @@ var init_objectstoragedata = __esm(() => {
       storage_class: "storageClass",
       created_at: "createdAt",
       bucket_name: "bucketName",
-      access_key: "accessKey",
-      secret_key: "secretKey",
       retention_mode: "retentionMode",
       retention_period: "retentionPeriod"
     });
@@ -57679,14 +57743,13 @@ var init_objectstoragedata = __esm(() => {
     createdAt: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
     bucketName: stringType().optional(),
     endpoint: stringType().optional(),
-    accessKey: nullableType(stringType()).optional(),
-    secretKey: nullableType(stringType()).optional(),
     versioning: nullableType(booleanType()).optional(),
     locking: nullableType(booleanType()).optional(),
     retentionMode: nullableType(RetentionMode$outboundSchema).optional(),
     retentionPeriod: nullableType(numberType().int()).optional(),
     source: stringType().optional(),
     region: nullableType(lazyType(() => ObjectStorageDataRegion$outboundSchema)).optional(),
+    credentials: nullableType(lazyType(() => ObjectStorageDataCredentials$outboundSchema)).optional(),
     project: ProjectInclude$outboundSchema.optional(),
     team: TeamInclude$outboundSchema.optional()
   }).transform((v2) => {
@@ -57695,8 +57758,6 @@ var init_objectstoragedata = __esm(() => {
       storageClass: "storage_class",
       createdAt: "created_at",
       bucketName: "bucket_name",
-      accessKey: "access_key",
-      secretKey: "secret_key",
       retentionMode: "retention_mode",
       retentionPeriod: "retention_period"
     });
@@ -58115,6 +58176,131 @@ var init_plan = __esm(() => {
   });
 });
 
+// src/models/prefixdata.ts
+var PrefixDataType, PrefixDataSize, PrefixDataType$inboundSchema, PrefixDataType$outboundSchema, PrefixDataSize$inboundSchema, PrefixDataSize$outboundSchema, PrefixDataProject$inboundSchema, PrefixDataProject$outboundSchema, PrefixDataLocation$inboundSchema, PrefixDataLocation$outboundSchema, PrefixDataRegion$inboundSchema, PrefixDataRegion$outboundSchema, PrefixDataAttributes$inboundSchema, PrefixDataAttributes$outboundSchema, PrefixData$inboundSchema, PrefixData$outboundSchema;
+var init_prefixdata = __esm(() => {
+  init_v3();
+  init_primitives();
+  PrefixDataType = {
+    Prefixes: "prefixes"
+  };
+  PrefixDataSize = {
+    TwentySix: 26,
+    TwentySeven: 27,
+    TwentyEight: 28
+  };
+  PrefixDataType$inboundSchema = nativeEnumType(PrefixDataType);
+  PrefixDataType$outboundSchema = PrefixDataType$inboundSchema;
+  PrefixDataSize$inboundSchema = nativeEnumType(PrefixDataSize);
+  PrefixDataSize$outboundSchema = PrefixDataSize$inboundSchema;
+  PrefixDataProject$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional()
+  });
+  PrefixDataProject$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional()
+  });
+  PrefixDataLocation$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional()
+  });
+  PrefixDataLocation$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    slug: stringType().optional()
+  });
+  PrefixDataRegion$inboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    location: lazyType(() => PrefixDataLocation$inboundSchema).optional()
+  });
+  PrefixDataRegion$outboundSchema = objectType({
+    id: stringType().optional(),
+    name: stringType().optional(),
+    location: lazyType(() => PrefixDataLocation$outboundSchema).optional()
+  });
+  PrefixDataAttributes$inboundSchema = objectType({
+    ipv4: stringType().optional(),
+    ipv6: nullableType(stringType()).optional(),
+    size: PrefixDataSize$inboundSchema.optional(),
+    activated: booleanType().optional(),
+    capacity: numberType().int().optional(),
+    ips_used: numberType().int().optional(),
+    ips_free: numberType().int().optional(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    project: nullableType(lazyType(() => PrefixDataProject$inboundSchema)).optional(),
+    region: nullableType(lazyType(() => PrefixDataRegion$inboundSchema)).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      ips_used: "ipsUsed",
+      ips_free: "ipsFree",
+      created_at: "createdAt"
+    });
+  });
+  PrefixDataAttributes$outboundSchema = objectType({
+    ipv4: stringType().optional(),
+    ipv6: nullableType(stringType()).optional(),
+    size: PrefixDataSize$outboundSchema.optional(),
+    activated: booleanType().optional(),
+    capacity: numberType().int().optional(),
+    ipsUsed: numberType().int().optional(),
+    ipsFree: numberType().int().optional(),
+    createdAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    project: nullableType(lazyType(() => PrefixDataProject$outboundSchema)).optional(),
+    region: nullableType(lazyType(() => PrefixDataRegion$outboundSchema)).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      ipsUsed: "ips_used",
+      ipsFree: "ips_free",
+      createdAt: "created_at"
+    });
+  });
+  PrefixData$inboundSchema = objectType({
+    id: stringType().optional(),
+    type: PrefixDataType$inboundSchema.optional(),
+    attributes: lazyType(() => PrefixDataAttributes$inboundSchema).optional()
+  });
+  PrefixData$outboundSchema = objectType({
+    id: stringType().optional(),
+    type: PrefixDataType$outboundSchema.optional(),
+    attributes: lazyType(() => PrefixDataAttributes$outboundSchema).optional()
+  });
+});
+
+// src/models/prefix.ts
+var Prefix$inboundSchema, Prefix$outboundSchema;
+var init_prefix = __esm(() => {
+  init_v3();
+  init_prefixdata();
+  Prefix$inboundSchema = objectType({
+    data: PrefixData$inboundSchema.optional()
+  });
+  Prefix$outboundSchema = objectType({
+    data: PrefixData$outboundSchema.optional()
+  });
+});
+
+// src/models/prefixes.ts
+var PrefixesMeta$inboundSchema, PrefixesMeta$outboundSchema, Prefixes$inboundSchema, Prefixes$outboundSchema;
+var init_prefixes = __esm(() => {
+  init_v3();
+  init_prefixdata();
+  PrefixesMeta$inboundSchema = objectType({});
+  PrefixesMeta$outboundSchema = objectType({});
+  Prefixes$inboundSchema = objectType({
+    data: arrayType(PrefixData$inboundSchema).optional(),
+    meta: lazyType(() => PrefixesMeta$inboundSchema).optional()
+  });
+  Prefixes$outboundSchema = objectType({
+    data: arrayType(PrefixData$outboundSchema).optional(),
+    meta: lazyType(() => PrefixesMeta$outboundSchema).optional()
+  });
+});
+
 // src/models/project.ts
 var ProjectType, BillingType, BillingMethod, Environment, ProjectType$inboundSchema, ProjectType$outboundSchema, ProjectTag$inboundSchema, ProjectTag$outboundSchema, BillingType$inboundSchema, BillingType$outboundSchema, BillingMethod$inboundSchema, BillingMethod$outboundSchema, Environment$inboundSchema, Environment$outboundSchema, ProjectStats$inboundSchema, ProjectStats$outboundSchema, ProjectBilling$inboundSchema, ProjectBilling$outboundSchema, ProjectAttributes$inboundSchema, ProjectAttributes$outboundSchema, Project$inboundSchema, Project$outboundSchema;
 var init_project = __esm(() => {
@@ -59123,6 +59309,7 @@ var init_team = __esm(() => {
     virtual_machine: nullableType(numberType().int()).optional(),
     virtual_machine_gpu: nullableType(numberType().int()).optional(),
     elastic_ip: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtual_network: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -59144,6 +59331,7 @@ var init_team = __esm(() => {
     virtualMachine: nullableType(numberType().int()).optional(),
     virtualMachineGpu: nullableType(numberType().int()).optional(),
     elasticIp: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtualNetwork: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -59883,6 +60071,7 @@ var init_userteam = __esm(() => {
     virtual_machine: nullableType(numberType().int()).optional(),
     virtual_machine_gpu: nullableType(numberType().int()).optional(),
     elastic_ip: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtual_network: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -59904,6 +60093,7 @@ var init_userteam = __esm(() => {
     virtualMachine: nullableType(numberType().int()).optional(),
     virtualMachineGpu: nullableType(numberType().int()).optional(),
     elasticIp: nullableType(numberType().int()).optional(),
+    prefix: nullableType(numberType().int()).optional(),
     virtualNetwork: nullableType(numberType().int()).optional(),
     database: nullableType(numberType().int()).optional(),
     filesystem: nullableType(numberType().int()).optional(),
@@ -60012,8 +60202,8 @@ var init_userupdate = __esm(() => {
     email: stringType().optional(),
     authentication_factor_id: nullableType(stringType()).optional(),
     role: nullableType(stringType()).optional(),
-    created_at: stringType().optional(),
-    updated_at: stringType().optional()
+    created_at: nullableType(stringType()).optional(),
+    updated_at: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       first_name: "firstName",
@@ -60029,8 +60219,8 @@ var init_userupdate = __esm(() => {
     email: stringType().optional(),
     authenticationFactorId: nullableType(stringType()).optional(),
     role: nullableType(stringType()).optional(),
-    createdAt: stringType().optional(),
-    updatedAt: stringType().optional()
+    createdAt: nullableType(stringType()).optional(),
+    updatedAt: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       firstName: "first_name",
@@ -60640,7 +60830,7 @@ var init_virtualmachinepayload = __esm(() => {
 });
 
 // src/models/virtualmachineplans.ts
-var VirtualMachinePlansType, VirtualMachinePlansUnit, VirtualMachinePlansRegionStockLevel, VirtualMachinePlansStockLevel, VirtualMachinePlansType$inboundSchema, VirtualMachinePlansType$outboundSchema, Vcpu$inboundSchema, Vcpu$outboundSchema, VirtualMachinePlansNic$inboundSchema, VirtualMachinePlansNic$outboundSchema, VirtualMachinePlansUnit$inboundSchema, VirtualMachinePlansUnit$outboundSchema, Size$inboundSchema, Size$outboundSchema, Disk$inboundSchema, Disk$outboundSchema, VirtualMachinePlansSpecs$inboundSchema, VirtualMachinePlansSpecs$outboundSchema, VirtualMachinePlansUSD$inboundSchema, VirtualMachinePlansUSD$outboundSchema, VirtualMachinePlansBRL$inboundSchema, VirtualMachinePlansBRL$outboundSchema, VirtualMachinePlansPricing$inboundSchema, VirtualMachinePlansPricing$outboundSchema, VirtualMachinePlansLocations$inboundSchema, VirtualMachinePlansLocations$outboundSchema, VirtualMachinePlansRegionStockLevel$inboundSchema, VirtualMachinePlansRegionStockLevel$outboundSchema, VirtualMachinePlansRegion$inboundSchema, VirtualMachinePlansRegion$outboundSchema, VirtualMachinePlansStockLevel$inboundSchema, VirtualMachinePlansStockLevel$outboundSchema, VirtualMachinePlansAttributes$inboundSchema, VirtualMachinePlansAttributes$outboundSchema, VirtualMachinePlansData$inboundSchema, VirtualMachinePlansData$outboundSchema, VirtualMachinePlans$inboundSchema, VirtualMachinePlans$outboundSchema;
+var VirtualMachinePlansType, VirtualMachinePlansUnit, VirtualMachinePlansRegionStockLevel, VirtualMachinePlansStockLevel, VirtualMachinePlansType$inboundSchema, VirtualMachinePlansType$outboundSchema, Vcpu$inboundSchema, Vcpu$outboundSchema, VirtualMachinePlansNic$inboundSchema, VirtualMachinePlansNic$outboundSchema, VirtualMachinePlansUnit$inboundSchema, VirtualMachinePlansUnit$outboundSchema, VirtualMachinePlansSize$inboundSchema, VirtualMachinePlansSize$outboundSchema, Disk$inboundSchema, Disk$outboundSchema, VirtualMachinePlansSpecs$inboundSchema, VirtualMachinePlansSpecs$outboundSchema, VirtualMachinePlansUSD$inboundSchema, VirtualMachinePlansUSD$outboundSchema, VirtualMachinePlansBRL$inboundSchema, VirtualMachinePlansBRL$outboundSchema, VirtualMachinePlansPricing$inboundSchema, VirtualMachinePlansPricing$outboundSchema, VirtualMachinePlansLocations$inboundSchema, VirtualMachinePlansLocations$outboundSchema, VirtualMachinePlansRegionStockLevel$inboundSchema, VirtualMachinePlansRegionStockLevel$outboundSchema, VirtualMachinePlansRegion$inboundSchema, VirtualMachinePlansRegion$outboundSchema, VirtualMachinePlansStockLevel$inboundSchema, VirtualMachinePlansStockLevel$outboundSchema, VirtualMachinePlansAttributes$inboundSchema, VirtualMachinePlansAttributes$outboundSchema, VirtualMachinePlansData$inboundSchema, VirtualMachinePlansData$outboundSchema, VirtualMachinePlans$inboundSchema, VirtualMachinePlans$outboundSchema;
 var init_virtualmachineplans = __esm(() => {
   init_v3();
   init_primitives();
@@ -60684,21 +60874,21 @@ var init_virtualmachineplans = __esm(() => {
   });
   VirtualMachinePlansUnit$inboundSchema = nativeEnumType(VirtualMachinePlansUnit);
   VirtualMachinePlansUnit$outboundSchema = VirtualMachinePlansUnit$inboundSchema;
-  Size$inboundSchema = objectType({
+  VirtualMachinePlansSize$inboundSchema = objectType({
     amount: numberType().int().optional(),
     unit: VirtualMachinePlansUnit$inboundSchema.optional()
   });
-  Size$outboundSchema = objectType({
+  VirtualMachinePlansSize$outboundSchema = objectType({
     amount: numberType().int().optional(),
     unit: VirtualMachinePlansUnit$outboundSchema.optional()
   });
   Disk$inboundSchema = objectType({
     type: stringType().optional(),
-    size: lazyType(() => Size$inboundSchema).optional()
+    size: lazyType(() => VirtualMachinePlansSize$inboundSchema).optional()
   });
   Disk$outboundSchema = objectType({
     type: stringType().optional(),
-    size: lazyType(() => Size$outboundSchema).optional()
+    size: lazyType(() => VirtualMachinePlansSize$outboundSchema).optional()
   });
   VirtualMachinePlansSpecs$inboundSchema = objectType({
     memory: numberType().int().optional(),
@@ -61434,6 +61624,7 @@ var init_models = __esm(() => {
   init_createbgpsession();
   init_createelasticip();
   init_createkubernetescluster();
+  init_createprefix();
   init_customtag();
   init_customtagdata();
   init_customtags();
@@ -61475,6 +61666,9 @@ var init_models = __esm(() => {
   init_paginationmeta();
   init_plan();
   init_plandata();
+  init_prefix();
+  init_prefixdata();
+  init_prefixes();
   init_project();
   init_projectinclude();
   init_projects();
@@ -62262,14 +62456,16 @@ var init_createserverreinstall = __esm(() => {
     raid: nullableType(CreateServerReinstallRaid2$inboundSchema).optional(),
     disk_layout: nullableType(arrayType(lazyType(() => CreateServerReinstallDiskLayout2$inboundSchema))).optional(),
     ipxe: nullableType(stringType()).optional(),
-    persistent_netboot: booleanType().optional()
+    persistent_netboot: booleanType().optional(),
+    prefix_id: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       operating_system: "operatingSystem",
       ssh_keys: "sshKeys",
       user_data: "userData",
       disk_layout: "diskLayout",
-      persistent_netboot: "persistentNetboot"
+      persistent_netboot: "persistentNetboot",
+      prefix_id: "prefixId"
     });
   });
   CreateServerReinstallAttributes2$outboundSchema = objectType({
@@ -62280,14 +62476,16 @@ var init_createserverreinstall = __esm(() => {
     raid: nullableType(CreateServerReinstallRaid2$outboundSchema).optional(),
     diskLayout: nullableType(arrayType(lazyType(() => CreateServerReinstallDiskLayout2$outboundSchema))).optional(),
     ipxe: nullableType(stringType()).optional(),
-    persistentNetboot: booleanType().optional()
+    persistentNetboot: booleanType().optional(),
+    prefixId: nullableType(stringType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       operatingSystem: "operating_system",
       sshKeys: "ssh_keys",
       userData: "user_data",
       diskLayout: "disk_layout",
-      persistentNetboot: "persistent_netboot"
+      persistentNetboot: "persistent_netboot",
+      prefixId: "prefix_id"
     });
   });
   CreateServerReinstallData2$inboundSchema = objectType({
@@ -62959,6 +63157,18 @@ var init_destroybaseline = __esm(() => {
   });
 });
 
+// src/models/operations/destroyprefix.ts
+var DestroyPrefixRequest$inboundSchema, DestroyPrefixRequest$outboundSchema;
+var init_destroyprefix = __esm(() => {
+  init_v3();
+  DestroyPrefixRequest$inboundSchema = objectType({
+    id: stringType()
+  });
+  DestroyPrefixRequest$outboundSchema = objectType({
+    id: stringType()
+  });
+});
+
 // src/models/operations/destroyserver.ts
 var DestroyServerRequest$inboundSchema, DestroyServerRequest$outboundSchema;
 var init_destroyserver = __esm(() => {
@@ -63730,6 +63940,43 @@ var init_getplansoperatingsystem = __esm(() => {
   });
 });
 
+// src/models/operations/getprefix.ts
+var GetPrefixRequest$inboundSchema, GetPrefixRequest$outboundSchema;
+var init_getprefix = __esm(() => {
+  init_v3();
+  GetPrefixRequest$inboundSchema = objectType({
+    id: stringType()
+  });
+  GetPrefixRequest$outboundSchema = objectType({
+    id: stringType()
+  });
+});
+
+// src/models/operations/getprefixes.ts
+var GetPrefixesRequest$inboundSchema, GetPrefixesRequest$outboundSchema;
+var init_getprefixes = __esm(() => {
+  init_v3();
+  init_primitives();
+  GetPrefixesRequest$inboundSchema = objectType({
+    "filter[project]": stringType().optional(),
+    "filter[site]": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "filter[project]": "filterProject",
+      "filter[site]": "filterSite"
+    });
+  });
+  GetPrefixesRequest$outboundSchema = objectType({
+    filterProject: stringType().optional(),
+    filterSite: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      filterProject: "filter[project]",
+      filterSite: "filter[site]"
+    });
+  });
+});
+
 // src/models/operations/getprojects.ts
 var GetProjectsRequest$inboundSchema, GetProjectsRequest$outboundSchema, GetProjectsResponse$inboundSchema, GetProjectsResponse$outboundSchema;
 var init_getprojects = __esm(() => {
@@ -67454,6 +67701,7 @@ var init_operations = __esm(() => {
   init_deletevirtualnetworksassignments();
   init_deletevpnsession();
   init_destroybaseline();
+  init_destroyprefix();
   init_destroyserver();
   init_destroytag();
   init_destroyteammember();
@@ -67476,6 +67724,8 @@ var init_operations = __esm(() => {
   init_getplan();
   init_getplans();
   init_getplansoperatingsystem();
+  init_getprefix();
+  init_getprefixes();
   init_getprojects();
   init_getprojectsshkey();
   init_getprojectsshkeys();
@@ -74809,18 +75059,18 @@ var init_plansVmList2 = __esm(() => {
   };
 });
 
-// src/funcs/privateNetworksAssign.ts
-function privateNetworksAssign(client, request, options) {
+// src/funcs/prefixesCreatePrefix.ts
+function prefixesCreatePrefix(client, request, options) {
   return new APIPromise($do64(client, request, options));
 }
 async function $do64(client, request, options) {
-  const parsed = safeParse4(request, (value) => AssignServerVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => CreatePrefix$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_networks/assignments")();
+  const path = pathToFunc("/prefixes")();
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/vnd.api+json"
@@ -74831,7 +75081,7 @@ async function $do64(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "assign-server-virtual-network",
+    operationID: "create-prefix",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -74862,15 +75112,20 @@ async function $do64(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(201, VirtualNetworkAssignment$inboundSchema, {
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, Prefix$inboundSchema, {
     ctype: "application/vnd.api+json"
-  }), fail("4XX"), fail("5XX"))(response, req);
+  }), jsonErr([403, 409, 422], 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_privateNetworksAssign = __esm(() => {
+var init_prefixesCreatePrefix = __esm(() => {
   init_encodings();
   init_http();
   init_matchers();
@@ -74878,26 +75133,28 @@ var init_privateNetworksAssign = __esm(() => {
   init_schemas4();
   init_security();
   init_url();
+  init_errors4();
   init_models();
-  init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/privateNetworksAssign.ts
-var args60, tool$privateNetworksAssign;
-var init_privateNetworksAssign2 = __esm(() => {
-  init_privateNetworksAssign();
-  init_operations();
+// src/mcp-server/tools/prefixesCreatePrefix.ts
+var args60, tool$prefixesCreatePrefix;
+var init_prefixesCreatePrefix2 = __esm(() => {
+  init_prefixesCreatePrefix();
+  init_models();
   init_tools();
   args60 = {
-    request: AssignServerVirtualNetworkRequest$inboundSchema
+    request: CreatePrefix$inboundSchema
   };
-  tool$privateNetworksAssign = {
-    name: "private-networks-assign",
-    description: `Assign VLAN`,
+  tool$prefixesCreatePrefix = {
+    name: "prefixes-create-prefix",
+    description: `Create a network
+
+Provision a customer network: an IPv4 block of the chosen size plus a paired IPv6 /64`,
     args: args60,
     tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await privateNetworksAssign(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await prefixesCreatePrefix(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74910,20 +75167,25 @@ var init_privateNetworksAssign2 = __esm(() => {
   };
 });
 
-// src/funcs/privateNetworksCreate.ts
-function privateNetworksCreate(client, request, options) {
+// src/funcs/prefixesDestroyPrefix.ts
+function prefixesDestroyPrefix(client, request, options) {
   return new APIPromise($do65(client, request, options));
 }
 async function $do65(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => DestroyPrefixRequest$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_networks")();
+  const body = null;
+  const pathParams = {
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/prefixes/{id}")(pathParams);
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/vnd.api+json"
   }));
   const secConfig = await extractSecurity(client._options.bearer);
@@ -74932,7 +75194,7 @@ async function $do65(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create-virtual-network",
+    operationID: "destroy-prefix",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearer,
@@ -74941,7 +75203,441 @@ async function $do65(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    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 responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(nil(204, voidType()), jsonErr([403, 404, 422], 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_prefixesDestroyPrefix = __esm(() => {
+  init_v3();
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/prefixesDestroyPrefix.ts
+var args61, tool$prefixesDestroyPrefix;
+var init_prefixesDestroyPrefix2 = __esm(() => {
+  init_prefixesDestroyPrefix();
+  init_operations();
+  init_tools();
+  args61 = {
+    request: DestroyPrefixRequest$inboundSchema
+  };
+  tool$prefixesDestroyPrefix = {
+    name: "prefixes-destroy-prefix",
+    description: `Delete a network
+
+Delete a customer network. Only allowed while the network has no IPs in use.`,
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await prefixesDestroyPrefix(client, args62.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/prefixesGetPrefix.ts
+function prefixesGetPrefix(client, request, options) {
+  return new APIPromise($do66(client, request, options));
+}
+async function $do66(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetPrefixRequest$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("/prefixes/{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-prefix",
+    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, Prefix$inboundSchema, {
+    ctype: "application/vnd.api+json"
+  }), jsonErr([403, 404], 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_prefixesGetPrefix = __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/prefixesGetPrefix.ts
+var args62, tool$prefixesGetPrefix;
+var init_prefixesGetPrefix2 = __esm(() => {
+  init_prefixesGetPrefix();
+  init_operations();
+  init_tools();
+  args62 = {
+    request: GetPrefixRequest$inboundSchema
+  };
+  tool$prefixesGetPrefix = {
+    name: "prefixes-get-prefix",
+    description: `Retrieve a network
+
+Retrieve a customer network`,
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await prefixesGetPrefix(client, args63.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/prefixesGetPrefixes.ts
+function prefixesGetPrefixes(client, request, options) {
+  return new APIPromise($do67(client, request, options));
+}
+async function $do67(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetPrefixesRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/prefixes")();
+  const query = encodeFormQuery({
+    "filter[project]": payload?.["filter[project]"],
+    "filter[site]": payload?.["filter[site]"]
+  });
+  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-prefixes",
+    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,
+    query,
+    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, Prefixes$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_prefixesGetPrefixes = __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/prefixesGetPrefixes.ts
+var args63, tool$prefixesGetPrefixes;
+var init_prefixesGetPrefixes2 = __esm(() => {
+  init_prefixesGetPrefixes();
+  init_operations();
+  init_tools();
+  args63 = {
+    request: GetPrefixesRequest$inboundSchema.optional()
+  };
+  tool$prefixesGetPrefixes = {
+    name: "prefixes-get-prefixes",
+    description: `List networks
+
+List the customer networks owned by the team`,
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await prefixesGetPrefixes(client, args64.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/privateNetworksAssign.ts
+function privateNetworksAssign(client, request, options) {
+  return new APIPromise($do68(client, request, options));
+}
+async function $do68(client, request, options) {
+  const parsed = safeParse4(request, (value) => AssignServerVirtualNetworkRequest$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_networks/assignments")();
+  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: "assign-server-virtual-network",
+    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, VirtualNetworkAssignment$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_privateNetworksAssign = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/privateNetworksAssign.ts
+var args64, tool$privateNetworksAssign;
+var init_privateNetworksAssign2 = __esm(() => {
+  init_privateNetworksAssign();
+  init_operations();
+  init_tools();
+  args64 = {
+    request: AssignServerVirtualNetworkRequest$inboundSchema
+  };
+  tool$privateNetworksAssign = {
+    name: "private-networks-assign",
+    description: `Assign VLAN`,
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await privateNetworksAssign(client, args65.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/privateNetworksCreate.ts
+function privateNetworksCreate(client, request, options) {
+  return new APIPromise($do69(client, request, options));
+}
+async function $do69(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateVirtualNetworkRequest$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_networks")();
+  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-network",
+    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,
@@ -74985,12 +75681,12 @@ var init_privateNetworksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksCreate.ts
-var args61, tool$privateNetworksCreate;
+var args65, tool$privateNetworksCreate;
 var init_privateNetworksCreate2 = __esm(() => {
   init_privateNetworksCreate();
   init_operations();
   init_tools();
-  args61 = {
+  args65 = {
     request: CreateVirtualNetworkRequest$inboundSchema
   };
   tool$privateNetworksCreate = {
@@ -74999,9 +75695,9 @@ var init_privateNetworksCreate2 = __esm(() => {
 
 Creates a new Virtual Network.
 `,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await privateNetworksCreate(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await privateNetworksCreate(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75016,9 +75712,9 @@ Creates a new Virtual Network.
 
 // src/funcs/privateNetworksDeleteAssignment.ts
 function privateNetworksDeleteAssignment(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVirtualNetworksAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75092,12 +75788,12 @@ var init_privateNetworksDeleteAssignment = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksDeleteAssignment.ts
-var args62, tool$privateNetworksDeleteAssignment;
+var args66, tool$privateNetworksDeleteAssignment;
 var init_privateNetworksDeleteAssignment2 = __esm(() => {
   init_privateNetworksDeleteAssignment();
   init_operations();
   init_tools();
-  args62 = {
+  args66 = {
     request: DeleteVirtualNetworksAssignmentsRequest$inboundSchema
   };
   tool$privateNetworksDeleteAssignment = {
@@ -75106,9 +75802,9 @@ var init_privateNetworksDeleteAssignment2 = __esm(() => {
 
 Allow you to remove a Virtual Network assignment.
 `,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await privateNetworksDeleteAssignment(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await privateNetworksDeleteAssignment(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75122,9 +75818,9 @@ Allow you to remove a Virtual Network assignment.
 
 // src/funcs/privateNetworksGet.ts
 function privateNetworksGet(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75200,12 +75896,12 @@ var init_privateNetworksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksGet.ts
-var args63, tool$privateNetworksGet;
+var args67, tool$privateNetworksGet;
 var init_privateNetworksGet2 = __esm(() => {
   init_privateNetworksGet();
   init_operations();
   init_tools();
-  args63 = {
+  args67 = {
     request: GetVirtualNetworkRequest$inboundSchema
   };
   tool$privateNetworksGet = {
@@ -75214,9 +75910,9 @@ var init_privateNetworksGet2 = __esm(() => {
 
 Retrieve a Virtual Network.
 `,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await privateNetworksGet(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await privateNetworksGet(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75231,9 +75927,9 @@ Retrieve a Virtual Network.
 
 // src/funcs/privateNetworksList.ts
 function privateNetworksList(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworksRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -75345,12 +76041,12 @@ var init_privateNetworksList = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksList.ts
-var args64, tool$privateNetworksList;
+var args68, tool$privateNetworksList;
 var init_privateNetworksList2 = __esm(() => {
   init_privateNetworksList();
   init_operations();
   init_tools();
-  args64 = {
+  args68 = {
     request: GetVirtualNetworksRequest$inboundSchema.optional()
   };
   tool$privateNetworksList = {
@@ -75359,9 +76055,9 @@ var init_privateNetworksList2 = __esm(() => {
 
 Lists virtual networks assigned to a project
 `,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await privateNetworksList(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await privateNetworksList(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75376,9 +76072,9 @@ Lists virtual networks assigned to a project
 
 // src/funcs/privateNetworksListAssignments.ts
 function privateNetworksListAssignments(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualNetworksAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -75487,12 +76183,12 @@ var init_privateNetworksListAssignments = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksListAssignments.ts
-var args65, tool$privateNetworksListAssignments;
+var args69, tool$privateNetworksListAssignments;
 var init_privateNetworksListAssignments2 = __esm(() => {
   init_privateNetworksListAssignments();
   init_operations();
   init_tools();
-  args65 = {
+  args69 = {
     request: GetVirtualNetworksAssignmentsRequest$inboundSchema.optional()
   };
   tool$privateNetworksListAssignments = {
@@ -75501,9 +76197,9 @@ var init_privateNetworksListAssignments2 = __esm(() => {
 
 Returns a list of all servers assigned to virtual networks.
 `,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await privateNetworksListAssignments(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await privateNetworksListAssignments(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75518,9 +76214,9 @@ Returns a list of all servers assigned to virtual networks.
 
 // src/funcs/privateNetworksUpdate.ts
 function privateNetworksUpdate(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75597,12 +76293,12 @@ var init_privateNetworksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/privateNetworksUpdate.ts
-var args66, tool$privateNetworksUpdate;
+var args70, tool$privateNetworksUpdate;
 var init_privateNetworksUpdate2 = __esm(() => {
   init_privateNetworksUpdate();
   init_operations();
   init_tools();
-  args66 = {
+  args70 = {
     request: UpdateVirtualNetworkRequest$inboundSchema
   };
   tool$privateNetworksUpdate = {
@@ -75611,9 +76307,9 @@ var init_privateNetworksUpdate2 = __esm(() => {
 
 Update a Virtual Network.
 `,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await privateNetworksUpdate(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await privateNetworksUpdate(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75628,9 +76324,9 @@ Update a Virtual Network.
 
 // src/funcs/projectsCreate.ts
 function projectsCreate(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75700,20 +76396,20 @@ var init_projectsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/projectsCreate.ts
-var args67, tool$projectsCreate;
+var args71, tool$projectsCreate;
 var init_projectsCreate2 = __esm(() => {
   init_projectsCreate();
   init_operations();
   init_tools();
-  args67 = {
+  args71 = {
     request: CreateProjectRequest$inboundSchema
   };
   tool$projectsCreate = {
     name: "projects-create",
     description: `Create project`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await projectsCreate(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await projectsCreate(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75728,9 +76424,9 @@ var init_projectsCreate2 = __esm(() => {
 
 // src/funcs/projectsDelete.ts
 function projectsDelete(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75804,12 +76500,12 @@ var init_projectsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/projectsDelete.ts
-var args68, tool$projectsDelete;
+var args72, tool$projectsDelete;
 var init_projectsDelete2 = __esm(() => {
   init_projectsDelete();
   init_operations();
   init_tools();
-  args68 = {
+  args72 = {
     request: DeleteProjectRequest$inboundSchema
   };
   tool$projectsDelete = {
@@ -75817,9 +76513,9 @@ var init_projectsDelete2 = __esm(() => {
     description: `Delete project
 
 Deletes a project and releases associated resources. Any Elastic IPs assigned to the project are automatically released and returned to the available pool.`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await projectsDelete(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await projectsDelete(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75833,9 +76529,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($do73(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -75951,12 +76647,12 @@ var init_projectsList = __esm(() => {
 });
 
 // src/mcp-server/tools/projectsList.ts
-var args69, tool$projectsList;
+var args73, tool$projectsList;
 var init_projectsList2 = __esm(() => {
   init_projectsList();
   init_operations();
   init_tools();
-  args69 = {
+  args73 = {
     request: GetProjectsRequest$inboundSchema.optional()
   };
   tool$projectsList = {
@@ -75965,9 +76661,9 @@ var init_projectsList2 = __esm(() => {
 
 Returns a list of all projects for the current team
 `,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await projectsList(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await projectsList(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75982,9 +76678,9 @@ Returns a list of all projects for the current team
 
 // src/funcs/projectsSshKeysPostProjectSshKey.ts
 function projectsSshKeysPostProjectSshKey(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse4(request, (value) => PostProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76060,12 +76756,12 @@ var init_projectsSshKeysPostProjectSshKey = __esm(() => {
 });
 
 // src/mcp-server/tools/projectsSshKeysPostProjectSshKey.ts
-var args70, tool$projectsSshKeysPostProjectSshKey;
+var args74, tool$projectsSshKeysPostProjectSshKey;
 var init_projectsSshKeysPostProjectSshKey2 = __esm(() => {
   init_projectsSshKeysPostProjectSshKey();
   init_operations();
   init_tools();
-  args70 = {
+  args74 = {
     request: PostProjectSshKeyRequest$inboundSchema
   };
   tool$projectsSshKeysPostProjectSshKey = {
@@ -76074,9 +76770,9 @@ var init_projectsSshKeysPostProjectSshKey2 = __esm(() => {
 
 Allow you create SSH Keys in a project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await projectsSshKeysPostProjectSshKey(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await projectsSshKeysPostProjectSshKey(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76091,9 +76787,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($do75(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76169,20 +76865,20 @@ var init_projectsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/projectsUpdate.ts
-var args71, tool$projectsUpdate;
+var args75, tool$projectsUpdate;
 var init_projectsUpdate2 = __esm(() => {
   init_projectsUpdate();
   init_operations();
   init_tools();
-  args71 = {
+  args75 = {
     request: UpdateProjectRequest$inboundSchema
   };
   tool$projectsUpdate = {
     name: "projects-update",
     description: `Update project`,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await projectsUpdate(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await projectsUpdate(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76197,9 +76893,9 @@ var init_projectsUpdate2 = __esm(() => {
 
 // src/funcs/regionsFetch.ts
 function regionsFetch(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRegionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76275,20 +76971,20 @@ var init_regionsFetch = __esm(() => {
 });
 
 // src/mcp-server/tools/regionsFetch.ts
-var args72, tool$regionsFetch;
+var args76, tool$regionsFetch;
 var init_regionsFetch2 = __esm(() => {
   init_regionsFetch();
   init_operations();
   init_tools();
-  args72 = {
+  args76 = {
     request: GetRegionRequest$inboundSchema
   };
   tool$regionsFetch = {
     name: "regions-fetch",
     description: `Retrieve region`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await regionsFetch(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await regionsFetch(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76303,9 +76999,9 @@ var init_regionsFetch2 = __esm(() => {
 
 // src/funcs/regionsGet.ts
 function regionsGet(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRegionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -76414,12 +77110,12 @@ var init_regionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/regionsGet.ts
-var args73, tool$regionsGet;
+var args77, tool$regionsGet;
 var init_regionsGet2 = __esm(() => {
   init_regionsGet();
   init_operations();
   init_tools();
-  args73 = {
+  args77 = {
     request: GetRegionsRequest$inboundSchema.optional()
   };
   tool$regionsGet = {
@@ -76429,9 +77125,9 @@ var init_regionsGet2 = __esm(() => {
 Lists all [available locations](https://latitude.sh/locations). For server availability by location, please see the [Plans API](/reference/get-plans).
 
 `,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await regionsGet(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await regionsGet(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76446,9 +77142,9 @@ Lists all [available locations](https://latitude.sh/locations). For server avail
 
 // src/funcs/rolesGet.ts
 function rolesGet(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRoleIdRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76524,20 +77220,20 @@ var init_rolesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesGet.ts
-var args74, tool$rolesGet;
+var args78, tool$rolesGet;
 var init_rolesGet2 = __esm(() => {
   init_rolesGet();
   init_operations();
   init_tools();
-  args74 = {
+  args78 = {
     request: GetRoleIdRequest$inboundSchema
   };
   tool$rolesGet = {
     name: "roles-get",
     description: `Retrieve role`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await rolesGet(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await rolesGet(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76552,9 +77248,9 @@ var init_rolesGet2 = __esm(() => {
 
 // src/funcs/rolesList.ts
 function rolesList(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRolesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -76663,12 +77359,12 @@ var init_rolesList = __esm(() => {
 });
 
 // src/mcp-server/tools/rolesList.ts
-var args75, tool$rolesList;
+var args79, tool$rolesList;
 var init_rolesList2 = __esm(() => {
   init_rolesList();
   init_operations();
   init_tools();
-  args75 = {
+  args79 = {
     request: GetRolesRequest$inboundSchema.optional()
   };
   tool$rolesList = {
@@ -76677,9 +77373,9 @@ var init_rolesList2 = __esm(() => {
 
 Returns a list of all roles that can be assigned to users
 `,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await rolesList(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await rolesList(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76694,9 +77390,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($do80(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76767,20 +77463,20 @@ var init_serversCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/serversCreate.ts
-var args76, tool$serversCreate;
+var args80, tool$serversCreate;
 var init_serversCreate2 = __esm(() => {
   init_serversCreate();
   init_operations();
   init_tools();
-  args76 = {
+  args80 = {
     request: CreateServerRequest$inboundSchema
   };
   tool$serversCreate = {
     name: "servers-create",
     description: `Create server`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await serversCreate(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await serversCreate(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76795,9 +77491,9 @@ var init_serversCreate2 = __esm(() => {
 
 // src/funcs/serversCreateIpmiSession.ts
 function serversCreateIpmiSession(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateIpmiSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76873,12 +77569,12 @@ var init_serversCreateIpmiSession = __esm(() => {
 });
 
 // src/mcp-server/tools/serversCreateIpmiSession.ts
-var args77, tool$serversCreateIpmiSession;
+var args81, tool$serversCreateIpmiSession;
 var init_serversCreateIpmiSession2 = __esm(() => {
   init_serversCreateIpmiSession();
   init_operations();
   init_tools();
-  args77 = {
+  args81 = {
     request: CreateIpmiSessionRequest$inboundSchema
   };
   tool$serversCreateIpmiSession = {
@@ -76890,9 +77586,9 @@ You will have to use a VPN client such as https://openvpn.net to connect. See \`
 
 Related guide: https://docs.latitude.sh/docs/ipmi
 `,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await serversCreateIpmiSession(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args81,
+    tool: async (client, args82, ctx) => {
+      const [result, apiCall] = await serversCreateIpmiSession(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76907,9 +77603,9 @@ Related guide: https://docs.latitude.sh/docs/ipmi
 
 // src/funcs/serversDelete.ts
 function serversDelete(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do86(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do86(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76987,20 +77683,20 @@ var init_serversDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/serversDelete.ts
-var args78, tool$serversDelete;
+var args82, tool$serversDelete;
 var init_serversDelete2 = __esm(() => {
   init_serversDelete();
   init_operations();
   init_tools();
-  args78 = {
+  args82 = {
     request: DestroyServerRequest$inboundSchema
   };
   tool$serversDelete = {
     name: "servers-delete",
     description: `Remove server`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await serversDelete(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args82,
+    tool: async (client, args83, ctx) => {
+      const [result, apiCall] = await serversDelete(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77014,9 +77710,9 @@ var init_serversDelete2 = __esm(() => {
 
 // src/funcs/serversExitRescueMode.ts
 function serversExitRescueMode(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do87(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do87(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerExitRescueModeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77092,12 +77788,12 @@ var init_serversExitRescueMode = __esm(() => {
 });
 
 // src/mcp-server/tools/serversExitRescueMode.ts
-var args79, tool$serversExitRescueMode;
+var args83, tool$serversExitRescueMode;
 var init_serversExitRescueMode2 = __esm(() => {
   init_serversExitRescueMode();
   init_operations();
   init_tools();
-  args79 = {
+  args83 = {
     request: ServerExitRescueModeRequest$inboundSchema
   };
   tool$serversExitRescueMode = {
@@ -77105,9 +77801,9 @@ var init_serversExitRescueMode2 = __esm(() => {
     description: `Exits rescue mode
 
 Exits rescue mode on a given server.`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await serversExitRescueMode(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args83,
+    tool: async (client, args84, ctx) => {
+      const [result, apiCall] = await serversExitRescueMode(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77122,9 +77818,9 @@ Exits rescue mode on a given server.`,
 
 // src/funcs/serversGet.ts
 function serversGet(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77204,12 +77900,12 @@ var init_serversGet = __esm(() => {
 });
 
 // src/mcp-server/tools/serversGet.ts
-var args80, tool$serversGet;
+var args84, tool$serversGet;
 var init_serversGet2 = __esm(() => {
   init_serversGet();
   init_operations();
   init_tools();
-  args80 = {
+  args84 = {
     request: GetServerRequest$inboundSchema
   };
   tool$serversGet = {
@@ -77218,9 +77914,9 @@ var init_serversGet2 = __esm(() => {
 
 Returns a server that belongs to the team.
 `,
-    args: args80,
-    tool: async (client, args81, ctx) => {
-      const [result, apiCall] = await serversGet(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args84,
+    tool: async (client, args85, ctx) => {
+      const [result, apiCall] = await serversGet(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77235,9 +77931,9 @@ Returns a server that belongs to the team.
 
 // src/funcs/serversGetDeployConfig.ts
 function serversGetDeployConfig(client, request, options) {
-  return new APIPromise($do85(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do85(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerDeployConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77313,20 +78009,20 @@ var init_serversGetDeployConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/serversGetDeployConfig.ts
-var args81, tool$serversGetDeployConfig;
+var args85, tool$serversGetDeployConfig;
 var init_serversGetDeployConfig2 = __esm(() => {
   init_serversGetDeployConfig();
   init_operations();
   init_tools();
-  args81 = {
+  args85 = {
     request: GetServerDeployConfigRequest$inboundSchema
   };
   tool$serversGetDeployConfig = {
     name: "servers-get-deploy-config",
     description: `Retrieve deploy config`,
-    args: args81,
-    tool: async (client, args82, ctx) => {
-      const [result, apiCall] = await serversGetDeployConfig(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args85,
+    tool: async (client, args86, ctx) => {
+      const [result, apiCall] = await serversGetDeployConfig(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77341,9 +78037,9 @@ var init_serversGetDeployConfig2 = __esm(() => {
 
 // src/funcs/serversGetOutOfBand.ts
 function serversGetOutOfBand(client, request, options) {
-  return new APIPromise($do86(client, request, options));
+  return new APIPromise($do90(client, request, options));
 }
-async function $do86(client, request, options) {
+async function $do90(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServerOutOfBandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77419,20 +78115,20 @@ var init_serversGetOutOfBand = __esm(() => {
 });
 
 // src/mcp-server/tools/serversGetOutOfBand.ts
-var args82, tool$serversGetOutOfBand;
+var args86, tool$serversGetOutOfBand;
 var init_serversGetOutOfBand2 = __esm(() => {
   init_serversGetOutOfBand();
   init_operations();
   init_tools();
-  args82 = {
+  args86 = {
     request: GetServerOutOfBandRequest$inboundSchema
   };
   tool$serversGetOutOfBand = {
     name: "servers-get-out-of-band",
     description: `List out-of-band connections`,
-    args: args82,
-    tool: async (client, args83, ctx) => {
-      const [result, apiCall] = await serversGetOutOfBand(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args86,
+    tool: async (client, args87, ctx) => {
+      const [result, apiCall] = await serversGetOutOfBand(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77447,9 +78143,9 @@ var init_serversGetOutOfBand2 = __esm(() => {
 
 // src/funcs/serversList.ts
 function serversList(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse4(request, (value) => GetServersRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -77575,12 +78271,12 @@ var init_serversList = __esm(() => {
 });
 
 // src/mcp-server/tools/serversList.ts
-var args83, tool$serversList;
+var args87, tool$serversList;
 var init_serversList2 = __esm(() => {
   init_serversList();
   init_operations();
   init_tools();
-  args83 = {
+  args87 = {
     request: GetServersRequest$inboundSchema.optional()
   };
   tool$serversList = {
@@ -77589,9 +78285,9 @@ var init_serversList2 = __esm(() => {
 
 Returns a list of all servers belonging to the team.
 `,
-    args: args83,
-    tool: async (client, args84, ctx) => {
-      const [result, apiCall] = await serversList(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args87,
+    tool: async (client, args88, ctx) => {
+      const [result, apiCall] = await serversList(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77606,9 +78302,9 @@ Returns a list of all servers belonging to the team.
 
 // src/funcs/serversLock.ts
 function serversLock(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerLockRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77684,12 +78380,12 @@ var init_serversLock = __esm(() => {
 });
 
 // src/mcp-server/tools/serversLock.ts
-var args84, tool$serversLock;
+var args88, tool$serversLock;
 var init_serversLock2 = __esm(() => {
   init_serversLock();
   init_operations();
   init_tools();
-  args84 = {
+  args88 = {
     request: ServerLockRequest$inboundSchema
   };
   tool$serversLock = {
@@ -77697,9 +78393,9 @@ var init_serversLock2 = __esm(() => {
     description: `Lock server
 
 Locks the server. A locked server cannot be deleted or modified and no actions can be performed on it.`,
-    args: args84,
-    tool: async (client, args85, ctx) => {
-      const [result, apiCall] = await serversLock(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args88,
+    tool: async (client, args89, ctx) => {
+      const [result, apiCall] = await serversLock(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77714,9 +78410,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($do89(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerReinstallRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77774,7 +78470,7 @@ async function $do89(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(201, voidType()), jsonErr([404, 422], ErrorObject$inboundSchema, {
+  const [result] = await match(nil(201, voidType()), jsonErr([403, 404, 422], ErrorObject$inboundSchema, {
     ctype: "application/vnd.api+json"
   }), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
@@ -77797,20 +78493,20 @@ var init_serversReinstall = __esm(() => {
 });
 
 // src/mcp-server/tools/serversReinstall.ts
-var args85, tool$serversReinstall;
+var args89, tool$serversReinstall;
 var init_serversReinstall2 = __esm(() => {
   init_serversReinstall();
   init_operations();
   init_tools();
-  args85 = {
+  args89 = {
     request: CreateServerReinstallRequest$inboundSchema
   };
   tool$serversReinstall = {
     name: "servers-reinstall",
     description: `Run Server Reinstall`,
-    args: args85,
-    tool: async (client, args86, ctx) => {
-      const [result, apiCall] = await serversReinstall(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args89,
+    tool: async (client, args90, ctx) => {
+      const [result, apiCall] = await serversReinstall(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77824,9 +78520,9 @@ var init_serversReinstall2 = __esm(() => {
 
 // src/funcs/serversRunAction.ts
 function serversRunAction(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerActionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77903,12 +78599,12 @@ var init_serversRunAction = __esm(() => {
 });
 
 // src/mcp-server/tools/serversRunAction.ts
-var args86, tool$serversRunAction;
+var args90, tool$serversRunAction;
 var init_serversRunAction2 = __esm(() => {
   init_serversRunAction();
   init_operations();
   init_tools();
-  args86 = {
+  args90 = {
     request: CreateServerActionRequest$inboundSchema
   };
   tool$serversRunAction = {
@@ -77920,9 +78616,9 @@ Performs an action on a given server:
 - \`power_off\`
 - \`reboot\`
 `,
-    args: args86,
-    tool: async (client, args87, ctx) => {
-      const [result, apiCall] = await serversRunAction(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args90,
+    tool: async (client, args91, ctx) => {
+      const [result, apiCall] = await serversRunAction(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77937,9 +78633,9 @@ Performs an action on a given server:
 
 // src/funcs/serversScheduleDeletion.ts
 function serversScheduleDeletion(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do95(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do95(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerScheduleDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78015,12 +78711,12 @@ var init_serversScheduleDeletion = __esm(() => {
 });
 
 // src/mcp-server/tools/serversScheduleDeletion.ts
-var args87, tool$serversScheduleDeletion;
+var args91, tool$serversScheduleDeletion;
 var init_serversScheduleDeletion2 = __esm(() => {
   init_serversScheduleDeletion();
   init_operations();
   init_tools();
-  args87 = {
+  args91 = {
     request: ServerScheduleDeletionRequest$inboundSchema
   };
   tool$serversScheduleDeletion = {
@@ -78028,9 +78724,9 @@ var init_serversScheduleDeletion2 = __esm(() => {
     description: `Schedule server deletion
 
 Schedules the server to be removed at the end of the billing cycle.`,
-    args: args87,
-    tool: async (client, args88, ctx) => {
-      const [result, apiCall] = await serversScheduleDeletion(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await serversScheduleDeletion(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78045,9 +78741,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($do92(client, request, options));
+  return new APIPromise($do96(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do96(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateServerOutOfBandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78124,20 +78820,20 @@ var init_serversStartOutOfBandConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/serversStartOutOfBandConnection.ts
-var args88, tool$serversStartOutOfBandConnection;
+var args92, tool$serversStartOutOfBandConnection;
 var init_serversStartOutOfBandConnection2 = __esm(() => {
   init_serversStartOutOfBandConnection();
   init_operations();
   init_tools();
-  args88 = {
+  args92 = {
     request: CreateServerOutOfBandRequest$inboundSchema
   };
   tool$serversStartOutOfBandConnection = {
     name: "servers-start-out-of-band-connection",
     description: `Create out-of-band connection`,
-    args: args88,
-    tool: async (client, args89, ctx) => {
-      const [result, apiCall] = await serversStartOutOfBandConnection(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await serversStartOutOfBandConnection(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78152,9 +78848,9 @@ var init_serversStartOutOfBandConnection2 = __esm(() => {
 
 // src/funcs/serversStartRescueMode.ts
 function serversStartRescueMode(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do97(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do97(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerStartRescueModeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78230,12 +78926,12 @@ var init_serversStartRescueMode = __esm(() => {
 });
 
 // src/mcp-server/tools/serversStartRescueMode.ts
-var args89, tool$serversStartRescueMode;
+var args93, tool$serversStartRescueMode;
 var init_serversStartRescueMode2 = __esm(() => {
   init_serversStartRescueMode();
   init_operations();
   init_tools();
-  args89 = {
+  args93 = {
     request: ServerStartRescueModeRequest$inboundSchema
   };
   tool$serversStartRescueMode = {
@@ -78243,9 +78939,9 @@ var init_serversStartRescueMode2 = __esm(() => {
     description: `Put server in rescue mode
 
 Starts rescue mode on a given server.`,
-    args: args89,
-    tool: async (client, args90, ctx) => {
-      const [result, apiCall] = await serversStartRescueMode(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await serversStartRescueMode(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78260,9 +78956,9 @@ Starts rescue mode on a given server.`,
 
 // src/funcs/serversUnlock.ts
 function serversUnlock(client, request, options) {
-  return new APIPromise($do94(client, request, options));
+  return new APIPromise($do98(client, request, options));
 }
-async function $do94(client, request, options) {
+async function $do98(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerUnlockRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78338,12 +79034,12 @@ var init_serversUnlock = __esm(() => {
 });
 
 // src/mcp-server/tools/serversUnlock.ts
-var args90, tool$serversUnlock;
+var args94, tool$serversUnlock;
 var init_serversUnlock2 = __esm(() => {
   init_serversUnlock();
   init_operations();
   init_tools();
-  args90 = {
+  args94 = {
     request: ServerUnlockRequest$inboundSchema
   };
   tool$serversUnlock = {
@@ -78351,9 +79047,9 @@ var init_serversUnlock2 = __esm(() => {
     description: `Unlock server
 
 Unlocks the server. A locked server cannot be deleted or modified and no actions can be performed on it.`,
-    args: args90,
-    tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await serversUnlock(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args94,
+    tool: async (client, args95, ctx) => {
+      const [result, apiCall] = await serversUnlock(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78368,9 +79064,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($do95(client, request, options));
+  return new APIPromise($do99(client, request, options));
 }
-async function $do95(client, request, options) {
+async function $do99(client, request, options) {
   const parsed = safeParse4(request, (value) => ServerUnscheduleDeletionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78444,12 +79140,12 @@ var init_serversUnscheduleDeletion = __esm(() => {
 });
 
 // src/mcp-server/tools/serversUnscheduleDeletion.ts
-var args91, tool$serversUnscheduleDeletion;
+var args95, tool$serversUnscheduleDeletion;
 var init_serversUnscheduleDeletion2 = __esm(() => {
   init_serversUnscheduleDeletion();
   init_operations();
   init_tools();
-  args91 = {
+  args95 = {
     request: ServerUnscheduleDeletionRequest$inboundSchema
   };
   tool$serversUnscheduleDeletion = {
@@ -78457,9 +79153,9 @@ var init_serversUnscheduleDeletion2 = __esm(() => {
     description: `Unschedule server deletion
 
 Unschedules the server removal at the end of the billing cycle.`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await serversUnscheduleDeletion(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args95,
+    tool: async (client, args96, ctx) => {
+      const [result, apiCall] = await serversUnscheduleDeletion(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78473,9 +79169,9 @@ Unschedules the server removal at the end of the billing cycle.`,
 
 // src/funcs/serversUpdate.ts
 function serversUpdate(client, request, options) {
-  return new APIPromise($do96(client, request, options));
+  return new APIPromise($do100(client, request, options));
 }
-async function $do96(client, request, options) {
+async function $do100(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateServerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78552,20 +79248,20 @@ var init_serversUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/serversUpdate.ts
-var args92, tool$serversUpdate;
+var args96, tool$serversUpdate;
 var init_serversUpdate2 = __esm(() => {
   init_serversUpdate();
   init_operations();
   init_tools();
-  args92 = {
+  args96 = {
     request: UpdateServerRequest$inboundSchema
   };
   tool$serversUpdate = {
     name: "servers-update",
     description: `Update server`,
-    args: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await serversUpdate(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args96,
+    tool: async (client, args97, ctx) => {
+      const [result, apiCall] = await serversUpdate(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78580,9 +79276,9 @@ var init_serversUpdate2 = __esm(() => {
 
 // src/funcs/serversUpdateDeployConfig.ts
 function serversUpdateDeployConfig(client, request, options) {
-  return new APIPromise($do97(client, request, options));
+  return new APIPromise($do101(client, request, options));
 }
-async function $do97(client, request, options) {
+async function $do101(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateServerDeployConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78659,20 +79355,20 @@ var init_serversUpdateDeployConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/serversUpdateDeployConfig.ts
-var args93, tool$serversUpdateDeployConfig;
+var args97, tool$serversUpdateDeployConfig;
 var init_serversUpdateDeployConfig2 = __esm(() => {
   init_serversUpdateDeployConfig();
   init_operations();
   init_tools();
-  args93 = {
+  args97 = {
     request: UpdateServerDeployConfigRequest$inboundSchema
   };
   tool$serversUpdateDeployConfig = {
     name: "servers-update-deploy-config",
     description: `Update deploy config`,
-    args: args93,
-    tool: async (client, args94, ctx) => {
-      const [result, apiCall] = await serversUpdateDeployConfig(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args97,
+    tool: async (client, args98, ctx) => {
+      const [result, apiCall] = await serversUpdateDeployConfig(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78687,9 +79383,9 @@ var init_serversUpdateDeployConfig2 = __esm(() => {
 
 // src/funcs/sshKeysCreate.ts
 function sshKeysCreate(client, request, options) {
-  return new APIPromise($do98(client, request, options));
+  return new APIPromise($do102(client, request, options));
 }
-async function $do98(client, request, options) {
+async function $do102(client, request, options) {
   const parsed = safeParse4(request, (value) => PostSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78759,12 +79455,12 @@ var init_sshKeysCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysCreate.ts
-var args94, tool$sshKeysCreate;
+var args98, tool$sshKeysCreate;
 var init_sshKeysCreate2 = __esm(() => {
   init_sshKeysCreate();
   init_operations();
   init_tools();
-  args94 = {
+  args98 = {
     request: PostSshKeyRequest$inboundSchema
   };
   tool$sshKeysCreate = {
@@ -78773,9 +79469,9 @@ var init_sshKeysCreate2 = __esm(() => {
 
 Allows you create SSH Keys. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args94,
-    tool: async (client, args95, ctx) => {
-      const [result, apiCall] = await sshKeysCreate(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args98,
+    tool: async (client, args99, ctx) => {
+      const [result, apiCall] = await sshKeysCreate(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78790,9 +79486,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($do99(client, request, options));
+  return new APIPromise($do103(client, request, options));
 }
-async function $do99(client, request, options) {
+async function $do103(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78866,12 +79562,12 @@ var init_sshKeysDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysDelete.ts
-var args95, tool$sshKeysDelete;
+var args99, tool$sshKeysDelete;
 var init_sshKeysDelete2 = __esm(() => {
   init_sshKeysDelete();
   init_operations();
   init_tools();
-  args95 = {
+  args99 = {
     request: DeleteSshKeyRequest$inboundSchema
   };
   tool$sshKeysDelete = {
@@ -78880,9 +79576,9 @@ var init_sshKeysDelete2 = __esm(() => {
 
 Allows you remove SSH Keys in a project. Remove a SSH Key from the project won't revoke the SSH Keys access for previously deploy and reinstall actions.
 `,
-    args: args95,
-    tool: async (client, args96, ctx) => {
-      const [result, apiCall] = await sshKeysDelete(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args99,
+    tool: async (client, args100, ctx) => {
+      const [result, apiCall] = await sshKeysDelete(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78896,9 +79592,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($do100(client, request, options));
+  return new APIPromise($do104(client, request, options));
 }
-async function $do100(client, request, options) {
+async function $do104(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78977,12 +79673,12 @@ var init_sshKeysGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysGet.ts
-var args96, tool$sshKeysGet;
+var args100, tool$sshKeysGet;
 var init_sshKeysGet2 = __esm(() => {
   init_sshKeysGet();
   init_operations();
   init_tools();
-  args96 = {
+  args100 = {
     request: GetProjectSshKeyRequest$inboundSchema
   };
   tool$sshKeysGet = {
@@ -78991,9 +79687,9 @@ var init_sshKeysGet2 = __esm(() => {
 
 List all SSH Keys in the project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args96,
-    tool: async (client, args97, ctx) => {
-      const [result, apiCall] = await sshKeysGet(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args100,
+    tool: async (client, args101, ctx) => {
+      const [result, apiCall] = await sshKeysGet(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79008,9 +79704,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($do101(client, request, options));
+  return new APIPromise($do105(client, request, options));
 }
-async function $do101(client, request, options) {
+async function $do105(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectSshKeysRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79093,12 +79789,12 @@ var init_sshKeysList = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysList.ts
-var args97, tool$sshKeysList;
+var args101, tool$sshKeysList;
 var init_sshKeysList2 = __esm(() => {
   init_sshKeysList();
   init_operations();
   init_tools();
-  args97 = {
+  args101 = {
     request: GetProjectSshKeysRequest$inboundSchema
   };
   tool$sshKeysList = {
@@ -79107,9 +79803,9 @@ var init_sshKeysList2 = __esm(() => {
 
 List all SSH Keys in the project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args97,
-    tool: async (client, args98, ctx) => {
-      const [result, apiCall] = await sshKeysList(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args101,
+    tool: async (client, args102, ctx) => {
+      const [result, apiCall] = await sshKeysList(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79124,9 +79820,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($do102(client, request, options));
+  return new APIPromise($do106(client, request, options));
 }
-async function $do102(client, request, options) {
+async function $do106(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSshKeysRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79205,12 +79901,12 @@ var init_sshKeysListAll = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysListAll.ts
-var args98, tool$sshKeysListAll;
+var args102, tool$sshKeysListAll;
 var init_sshKeysListAll2 = __esm(() => {
   init_sshKeysListAll();
   init_operations();
   init_tools();
-  args98 = {
+  args102 = {
     request: GetSshKeysRequest$inboundSchema.optional()
   };
   tool$sshKeysListAll = {
@@ -79219,9 +79915,9 @@ var init_sshKeysListAll2 = __esm(() => {
 
 List all SSH Keys in the project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args98,
-    tool: async (client, args99, ctx) => {
-      const [result, apiCall] = await sshKeysListAll(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args102,
+    tool: async (client, args103, ctx) => {
+      const [result, apiCall] = await sshKeysListAll(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79236,9 +79932,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($do103(client, request, options));
+  return new APIPromise($do107(client, request, options));
 }
-async function $do103(client, request, options) {
+async function $do107(client, request, options) {
   const parsed = safeParse4(request, (value) => PutProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79318,12 +80014,12 @@ var init_sshKeysModifyProjectKey = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysModifyProjectKey.ts
-var args99, tool$sshKeysModifyProjectKey;
+var args103, tool$sshKeysModifyProjectKey;
 var init_sshKeysModifyProjectKey2 = __esm(() => {
   init_sshKeysModifyProjectKey();
   init_operations();
   init_tools();
-  args99 = {
+  args103 = {
     request: PutProjectSshKeyRequest$inboundSchema
   };
   tool$sshKeysModifyProjectKey = {
@@ -79332,9 +80028,9 @@ var init_sshKeysModifyProjectKey2 = __esm(() => {
 
 Allow you update SSH Key in a project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args99,
-    tool: async (client, args100, ctx) => {
-      const [result, apiCall] = await sshKeysModifyProjectKey(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args103,
+    tool: async (client, args104, ctx) => {
+      const [result, apiCall] = await sshKeysModifyProjectKey(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79349,9 +80045,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($do104(client, request, options));
+  return new APIPromise($do108(client, request, options));
 }
-async function $do104(client, request, options) {
+async function $do108(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79429,12 +80125,12 @@ var init_sshKeysRemoveFromProject = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysRemoveFromProject.ts
-var args100, tool$sshKeysRemoveFromProject;
+var args104, tool$sshKeysRemoveFromProject;
 var init_sshKeysRemoveFromProject2 = __esm(() => {
   init_sshKeysRemoveFromProject();
   init_operations();
   init_tools();
-  args100 = {
+  args104 = {
     request: DeleteProjectSshKeyRequest$inboundSchema
   };
   tool$sshKeysRemoveFromProject = {
@@ -79443,9 +80139,9 @@ var init_sshKeysRemoveFromProject2 = __esm(() => {
 
 Allow you remove SSH Keys in a project. Remove a SSH Key from the project won't revoke the SSH Keys access for previously deploy and reinstall actions.
 `,
-    args: args100,
-    tool: async (client, args101, ctx) => {
-      const [result, apiCall] = await sshKeysRemoveFromProject(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args104,
+    tool: async (client, args105, ctx) => {
+      const [result, apiCall] = await sshKeysRemoveFromProject(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79459,9 +80155,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($do105(client, request, options));
+  return new APIPromise($do109(client, request, options));
 }
-async function $do105(client, request, options) {
+async function $do109(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79536,12 +80232,12 @@ var init_sshKeysRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysRetrieve.ts
-var args101, tool$sshKeysRetrieve;
+var args105, tool$sshKeysRetrieve;
 var init_sshKeysRetrieve2 = __esm(() => {
   init_sshKeysRetrieve();
   init_operations();
   init_tools();
-  args101 = {
+  args105 = {
     request: GetSshKeyRequest$inboundSchema
   };
   tool$sshKeysRetrieve = {
@@ -79550,9 +80246,9 @@ var init_sshKeysRetrieve2 = __esm(() => {
 
 List all SSH Keys in the project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args101,
-    tool: async (client, args102, ctx) => {
-      const [result, apiCall] = await sshKeysRetrieve(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await sshKeysRetrieve(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79567,9 +80263,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($do106(client, request, options));
+  return new APIPromise($do110(client, request, options));
 }
-async function $do106(client, request, options) {
+async function $do110(client, request, options) {
   const parsed = safeParse4(request, (value) => PutSshKeyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79645,12 +80341,12 @@ var init_sshKeysUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/sshKeysUpdate.ts
-var args102, tool$sshKeysUpdate;
+var args106, tool$sshKeysUpdate;
 var init_sshKeysUpdate2 = __esm(() => {
   init_sshKeysUpdate();
   init_operations();
   init_tools();
-  args102 = {
+  args106 = {
     request: PutSshKeyRequest$inboundSchema
   };
   tool$sshKeysUpdate = {
@@ -79659,9 +80355,9 @@ var init_sshKeysUpdate2 = __esm(() => {
 
 Allows you update SSH Key in a project. These keys can be used to access servers after deploy and reinstall actions.
 `,
-    args: args102,
-    tool: async (client, args103, ctx) => {
-      const [result, apiCall] = await sshKeysUpdate(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await sshKeysUpdate(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79676,9 +80372,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($do107(client, request, options));
+  return new APIPromise($do111(client, request, options));
 }
-async function $do107(client, request, options) {
+async function $do111(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79755,12 +80451,12 @@ var init_tagsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/tagsCreate.ts
-var args103, tool$tagsCreate;
+var args107, tool$tagsCreate;
 var init_tagsCreate2 = __esm(() => {
   init_tagsCreate();
   init_operations();
   init_tools();
-  args103 = {
+  args107 = {
     request: CreateTagRequest$inboundSchema
   };
   tool$tagsCreate = {
@@ -79769,9 +80465,9 @@ var init_tagsCreate2 = __esm(() => {
 
 Create a Tag in the team.
 `,
-    args: args103,
-    tool: async (client, args104, ctx) => {
-      const [result, apiCall] = await tagsCreate(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args107,
+    tool: async (client, args108, ctx) => {
+      const [result, apiCall] = await tagsCreate(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79786,9 +80482,9 @@ Create a Tag in the team.
 
 // src/funcs/tagsDelete.ts
 function tagsDelete(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+  return new APIPromise($do112(client, request, options));
 }
-async function $do108(client, request, options) {
+async function $do112(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79862,12 +80558,12 @@ var init_tagsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/tagsDelete.ts
-var args104, tool$tagsDelete;
+var args108, tool$tagsDelete;
 var init_tagsDelete2 = __esm(() => {
   init_tagsDelete();
   init_operations();
   init_tools();
-  args104 = {
+  args108 = {
     request: DestroyTagRequest$inboundSchema
   };
   tool$tagsDelete = {
@@ -79876,9 +80572,9 @@ var init_tagsDelete2 = __esm(() => {
 
 Update a Tag in the team.
 `,
-    args: args104,
-    tool: async (client, args105, ctx) => {
-      const [result, apiCall] = await tagsDelete(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await tagsDelete(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79892,9 +80588,9 @@ Update a Tag in the team.
 
 // src/funcs/tagsList.ts
 function tagsList(client, options) {
-  return new APIPromise($do109(client, options));
+  return new APIPromise($do113(client, options));
 }
-async function $do109(client, options) {
+async function $do113(client, options) {
   const path = pathToFunc("/tags")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -79980,9 +80676,9 @@ List all Tags in the team.
 
 // src/funcs/tagsUpdate.ts
 function tagsUpdate(client, request, options) {
-  return new APIPromise($do110(client, request, options));
+  return new APIPromise($do114(client, request, options));
 }
-async function $do110(client, request, options) {
+async function $do114(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateTagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80065,12 +80761,12 @@ var init_tagsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/tagsUpdate.ts
-var args105, tool$tagsUpdate;
+var args109, tool$tagsUpdate;
 var init_tagsUpdate2 = __esm(() => {
   init_tagsUpdate();
   init_operations();
   init_tools();
-  args105 = {
+  args109 = {
     request: UpdateTagRequest$inboundSchema
   };
   tool$tagsUpdate = {
@@ -80079,9 +80775,9 @@ var init_tagsUpdate2 = __esm(() => {
 
 Update a Tag in the team.
 `,
-    args: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await tagsUpdate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await tagsUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80096,9 +80792,9 @@ Update a Tag in the team.
 
 // src/funcs/teamMembersDelete.ts
 function teamMembersDelete(client, request, options) {
-  return new APIPromise($do111(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do111(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyTeamMemberRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80172,20 +80868,20 @@ var init_teamMembersDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/teamMembersDelete.ts
-var args106, tool$teamMembersDelete;
+var args110, tool$teamMembersDelete;
 var init_teamMembersDelete2 = __esm(() => {
   init_teamMembersDelete();
   init_operations();
   init_tools();
-  args106 = {
+  args110 = {
     request: DestroyTeamMemberRequest$inboundSchema
   };
   tool$teamMembersDelete = {
     name: "team-members-delete",
     description: `Remove a member`,
-    args: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await teamMembersDelete(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await teamMembersDelete(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80199,9 +80895,9 @@ var init_teamMembersDelete2 = __esm(() => {
 
 // src/funcs/teamMembersPostTeamMembers.ts
 function teamMembersPostTeamMembers(client, request, options) {
-  return new APIPromise($do112(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do112(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse4(request, (value) => PostTeamMembersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80272,20 +80968,20 @@ var init_teamMembersPostTeamMembers = __esm(() => {
 });
 
 // src/mcp-server/tools/teamMembersPostTeamMembers.ts
-var args107, tool$teamMembersPostTeamMembers;
+var args111, tool$teamMembersPostTeamMembers;
 var init_teamMembersPostTeamMembers2 = __esm(() => {
   init_teamMembersPostTeamMembers();
   init_operations();
   init_tools();
-  args107 = {
+  args111 = {
     request: PostTeamMembersRequest$inboundSchema
   };
   tool$teamMembersPostTeamMembers = {
     name: "team-members-post-team-members",
     description: `Create member`,
-    args: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await teamMembersPostTeamMembers(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await teamMembersPostTeamMembers(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80300,9 +80996,9 @@ var init_teamMembersPostTeamMembers2 = __esm(() => {
 
 // src/funcs/teamsCreate.ts
 function teamsCreate(client, request, options) {
-  return new APIPromise($do113(client, request, options));
+  return new APIPromise($do117(client, request, options));
 }
-async function $do113(client, request, options) {
+async function $do117(client, request, options) {
   const parsed = safeParse4(request, (value) => PostTeamRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80372,20 +81068,20 @@ var init_teamsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/teamsCreate.ts
-var args108, tool$teamsCreate;
+var args112, tool$teamsCreate;
 var init_teamsCreate2 = __esm(() => {
   init_teamsCreate();
   init_operations();
   init_tools();
-  args108 = {
+  args112 = {
     request: PostTeamRequest$inboundSchema
   };
   tool$teamsCreate = {
     name: "teams-create",
     description: `Create team`,
-    args: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await teamsCreate(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await teamsCreate(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80400,9 +81096,9 @@ var init_teamsCreate2 = __esm(() => {
 
 // src/funcs/teamsGet.ts
 function teamsGet(client, options) {
-  return new APIPromise($do114(client, options));
+  return new APIPromise($do118(client, options));
 }
-async function $do114(client, options) {
+async function $do118(client, options) {
   const path = pathToFunc("/team")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -80485,9 +81181,9 @@ var init_teamsGet2 = __esm(() => {
 
 // src/funcs/teamsMembersGetTeamMembers.ts
 function teamsMembersGetTeamMembers(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTeamMembersRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -80596,20 +81292,20 @@ var init_teamsMembersGetTeamMembers = __esm(() => {
 });
 
 // src/mcp-server/tools/teamsMembersGetTeamMembers.ts
-var args109, tool$teamsMembersGetTeamMembers;
+var args113, tool$teamsMembersGetTeamMembers;
 var init_teamsMembersGetTeamMembers2 = __esm(() => {
   init_teamsMembersGetTeamMembers();
   init_operations();
   init_tools();
-  args109 = {
+  args113 = {
     request: GetTeamMembersRequest$inboundSchema.optional()
   };
   tool$teamsMembersGetTeamMembers = {
     name: "teams-members-get-team-members",
     description: `List members`,
-    args: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await teamsMembersGetTeamMembers(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await teamsMembersGetTeamMembers(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80624,9 +81320,9 @@ var init_teamsMembersGetTeamMembers2 = __esm(() => {
 
 // src/funcs/teamsUpdate.ts
 function teamsUpdate(client, request, options) {
-  return new APIPromise($do116(client, request, options));
+  return new APIPromise($do120(client, request, options));
 }
-async function $do116(client, request, options) {
+async function $do120(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchCurrentTeamRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80702,20 +81398,20 @@ var init_teamsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/teamsUpdate.ts
-var args110, tool$teamsUpdate;
+var args114, tool$teamsUpdate;
 var init_teamsUpdate2 = __esm(() => {
   init_teamsUpdate();
   init_operations();
   init_tools();
-  args110 = {
+  args114 = {
     request: PatchCurrentTeamRequest$inboundSchema
   };
   tool$teamsUpdate = {
     name: "teams-update",
     description: `Update team`,
-    args: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await teamsUpdate(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await teamsUpdate(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80730,9 +81426,9 @@ var init_teamsUpdate2 = __esm(() => {
 
 // src/funcs/trafficGet.ts
 function trafficGet(client, request, options) {
-  return new APIPromise($do117(client, request, options));
+  return new APIPromise($do121(client, request, options));
 }
-async function $do117(client, request, options) {
+async function $do121(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTrafficConsumptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80809,20 +81505,20 @@ var init_trafficGet = __esm(() => {
 });
 
 // src/mcp-server/tools/trafficGet.ts
-var args111, tool$trafficGet;
+var args115, tool$trafficGet;
 var init_trafficGet2 = __esm(() => {
   init_trafficGet();
   init_operations();
   init_tools();
-  args111 = {
+  args115 = {
     request: GetTrafficConsumptionRequest$inboundSchema
   };
   tool$trafficGet = {
     name: "traffic-get",
     description: `Retrieve traffic`,
-    args: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await trafficGet(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await trafficGet(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80837,9 +81533,9 @@ var init_trafficGet2 = __esm(() => {
 
 // src/funcs/trafficGetQuota.ts
 function trafficGetQuota(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do122(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do122(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTrafficQuotaRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80913,20 +81609,20 @@ var init_trafficGetQuota = __esm(() => {
 });
 
 // src/mcp-server/tools/trafficGetQuota.ts
-var args112, tool$trafficGetQuota;
+var args116, tool$trafficGetQuota;
 var init_trafficGetQuota2 = __esm(() => {
   init_trafficGetQuota();
   init_operations();
   init_tools();
-  args112 = {
+  args116 = {
     request: GetTrafficQuotaRequest$inboundSchema.optional()
   };
   tool$trafficGetQuota = {
     name: "traffic-get-quota",
     description: `Retrieve traffic quota`,
-    args: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await trafficGetQuota(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await trafficGetQuota(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80941,9 +81637,9 @@ var init_trafficGetQuota2 = __esm(() => {
 
 // src/funcs/userDataCreate.ts
 function userDataCreate(client, request, options) {
-  return new APIPromise($do119(client, request, options));
+  return new APIPromise($do123(client, request, options));
 }
-async function $do119(client, request, options) {
+async function $do123(client, request, options) {
   const parsed = safeParse4(request, (value) => PostProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81020,12 +81716,12 @@ var init_userDataCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataCreate.ts
-var args113, tool$userDataCreate;
+var args117, tool$userDataCreate;
 var init_userDataCreate2 = __esm(() => {
   init_userDataCreate();
   init_operations();
   init_tools();
-  args113 = {
+  args117 = {
     request: PostProjectUserDataRequest$inboundSchema
   };
   tool$userDataCreate = {
@@ -81034,9 +81730,9 @@ var init_userDataCreate2 = __esm(() => {
 
 Allows you to create User Data in a project, which can be used to perform custom setup on your servers after deploy and reinstall.
 `,
-    args: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await userDataCreate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await userDataCreate(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81051,9 +81747,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($do120(client, request, options));
+  return new APIPromise($do124(client, request, options));
 }
-async function $do120(client, request, options) {
+async function $do124(client, request, options) {
   const parsed = safeParse4(request, (value) => PostUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81124,12 +81820,12 @@ var init_userDataCreateNew = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataCreateNew.ts
-var args114, tool$userDataCreateNew;
+var args118, tool$userDataCreateNew;
 var init_userDataCreateNew2 = __esm(() => {
   init_userDataCreateNew();
   init_operations();
   init_tools();
-  args114 = {
+  args118 = {
     request: PostUserDataRequest$inboundSchema
   };
   tool$userDataCreateNew = {
@@ -81138,9 +81834,9 @@ var init_userDataCreateNew2 = __esm(() => {
 
 Allows you to create User Data in a team, which can be used to perform custom setup on your servers after deploy and reinstall.
 `,
-    args: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await userDataCreateNew(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await userDataCreateNew(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81155,9 +81851,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($do121(client, request, options));
+  return new APIPromise($do125(client, request, options));
 }
-async function $do121(client, request, options) {
+async function $do125(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81231,20 +81927,20 @@ var init_userDataDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataDelete.ts
-var args115, tool$userDataDelete;
+var args119, tool$userDataDelete;
 var init_userDataDelete2 = __esm(() => {
   init_userDataDelete();
   init_operations();
   init_tools();
-  args115 = {
+  args119 = {
     request: DeleteUserDataRequest$inboundSchema
   };
   tool$userDataDelete = {
     name: "user-data-delete",
     description: `Delete user data`,
-    args: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await userDataDelete(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await userDataDelete(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81258,9 +81954,9 @@ var init_userDataDelete2 = __esm(() => {
 
 // src/funcs/userDataDeleteProjectUserData.ts
 function userDataDeleteProjectUserData(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+  return new APIPromise($do126(client, request, options));
 }
-async function $do122(client, request, options) {
+async function $do126(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81338,12 +82034,12 @@ var init_userDataDeleteProjectUserData = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataDeleteProjectUserData.ts
-var args116, tool$userDataDeleteProjectUserData;
+var args120, tool$userDataDeleteProjectUserData;
 var init_userDataDeleteProjectUserData2 = __esm(() => {
   init_userDataDeleteProjectUserData();
   init_operations();
   init_tools();
-  args116 = {
+  args120 = {
     request: DeleteProjectUserDataRequest$inboundSchema
   };
   tool$userDataDeleteProjectUserData = {
@@ -81352,9 +82048,9 @@ var init_userDataDeleteProjectUserData2 = __esm(() => {
 
 Allow you remove User Data in a project.
 `,
-    args: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await userDataDeleteProjectUserData(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await userDataDeleteProjectUserData(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81368,9 +82064,9 @@ Allow you remove User Data in a project.
 
 // src/funcs/userDataGetProjectUserData.ts
 function userDataGetProjectUserData(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do127(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do127(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81454,12 +82150,12 @@ var init_userDataGetProjectUserData = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataGetProjectUserData.ts
-var args117, tool$userDataGetProjectUserData;
+var args121, tool$userDataGetProjectUserData;
 var init_userDataGetProjectUserData2 = __esm(() => {
   init_userDataGetProjectUserData();
   init_operations();
   init_tools();
-  args117 = {
+  args121 = {
     request: GetProjectUserDataRequest$inboundSchema
   };
   tool$userDataGetProjectUserData = {
@@ -81468,9 +82164,9 @@ var init_userDataGetProjectUserData2 = __esm(() => {
 
 Get User Data in the project. These scripts can be used to configure servers with user data.
 `,
-    args: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await userDataGetProjectUserData(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await userDataGetProjectUserData(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81485,9 +82181,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($do124(client, request, options));
+  return new APIPromise($do128(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do128(client, request, options) {
   const parsed = safeParse4(request, (value) => GetProjectUsersDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81567,12 +82263,12 @@ var init_userDataGetProjectUsersData = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataGetProjectUsersData.ts
-var args118, tool$userDataGetProjectUsersData;
+var args122, tool$userDataGetProjectUsersData;
 var init_userDataGetProjectUsersData2 = __esm(() => {
   init_userDataGetProjectUsersData();
   init_operations();
   init_tools();
-  args118 = {
+  args122 = {
     request: GetProjectUsersDataRequest$inboundSchema
   };
   tool$userDataGetProjectUsersData = {
@@ -81581,9 +82277,9 @@ var init_userDataGetProjectUsersData2 = __esm(() => {
 
 List all Users Data in the project. These scripts can be used to configure servers with user data.
 `,
-    args: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await userDataGetProjectUsersData(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await userDataGetProjectUsersData(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81598,9 +82294,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($do125(client, request, options));
+  return new APIPromise($do129(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do129(client, request, options) {
   const parsed = safeParse4(request, (value) => GetUsersDataRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -81712,12 +82408,12 @@ var init_userDataList = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataList.ts
-var args119, tool$userDataList;
+var args123, tool$userDataList;
 var init_userDataList2 = __esm(() => {
   init_userDataList();
   init_operations();
   init_tools();
-  args119 = {
+  args123 = {
     request: GetUsersDataRequest$inboundSchema.optional()
   };
   tool$userDataList = {
@@ -81726,9 +82422,9 @@ var init_userDataList2 = __esm(() => {
 
 List all Users Data in the project. These scripts can be used to configure servers with user data.
 `,
-    args: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await userDataList(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await userDataList(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81743,9 +82439,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($do126(client, request, options));
+  return new APIPromise($do130(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do130(client, request, options) {
   const parsed = safeParse4(request, (value) => GetUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81825,12 +82521,12 @@ var init_userDataRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataRetrieve.ts
-var args120, tool$userDataRetrieve;
+var args124, tool$userDataRetrieve;
 var init_userDataRetrieve2 = __esm(() => {
   init_userDataRetrieve();
   init_operations();
   init_tools();
-  args120 = {
+  args124 = {
     request: GetUserDataRequest$inboundSchema
   };
   tool$userDataRetrieve = {
@@ -81839,9 +82535,9 @@ var init_userDataRetrieve2 = __esm(() => {
 
 Get User Data in the project. These scripts can be used to configure servers with user data.
 `,
-    args: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await userDataRetrieve(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await userDataRetrieve(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81856,9 +82552,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($do127(client, request, options));
+  return new APIPromise($do131(client, request, options));
 }
-async function $do127(client, request, options) {
+async function $do131(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81935,12 +82631,12 @@ var init_userDataUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataUpdate.ts
-var args121, tool$userDataUpdate;
+var args125, tool$userDataUpdate;
 var init_userDataUpdate2 = __esm(() => {
   init_userDataUpdate();
   init_operations();
   init_tools();
-  args121 = {
+  args125 = {
     request: PatchUserDataRequest$inboundSchema
   };
   tool$userDataUpdate = {
@@ -81949,9 +82645,9 @@ var init_userDataUpdate2 = __esm(() => {
 
 Allow you update User Data in a team.
 `,
-    args: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await userDataUpdate(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await userDataUpdate(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81966,9 +82662,9 @@ Allow you update User Data in a team.
 
 // src/funcs/userDataUpdateForProject.ts
 function userDataUpdateForProject(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do132(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do132(client, request, options) {
   const parsed = safeParse4(request, (value) => PutProjectUserDataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82049,12 +82745,12 @@ var init_userDataUpdateForProject = __esm(() => {
 });
 
 // src/mcp-server/tools/userDataUpdateForProject.ts
-var args122, tool$userDataUpdateForProject;
+var args126, tool$userDataUpdateForProject;
 var init_userDataUpdateForProject2 = __esm(() => {
   init_userDataUpdateForProject();
   init_operations();
   init_tools();
-  args122 = {
+  args126 = {
     request: PutProjectUserDataRequest$inboundSchema
   };
   tool$userDataUpdateForProject = {
@@ -82063,9 +82759,9 @@ var init_userDataUpdateForProject2 = __esm(() => {
 
 Allow you update User Data in a project.
 `,
-    args: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await userDataUpdateForProject(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await userDataUpdateForProject(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82080,9 +82776,9 @@ Allow you update User Data in a project.
 
 // src/funcs/userProfileGet.ts
 function userProfileGet(client, options) {
-  return new APIPromise($do129(client, options));
+  return new APIPromise($do133(client, options));
 }
-async function $do129(client, options) {
+async function $do133(client, options) {
   const path = pathToFunc("/user/profile")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -82168,9 +82864,9 @@ Retrieve the current user profile
 
 // src/funcs/userProfileListTeams.ts
 function userProfileListTeams(client, options) {
-  return new APIPromise($do130(client, options));
+  return new APIPromise($do134(client, options));
 }
-async function $do130(client, options) {
+async function $do134(client, options) {
   const path = pathToFunc("/user/teams")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -82256,9 +82952,9 @@ Returns a list of all teams the user belongs to
 
 // src/funcs/userProfileUpdate.ts
 function userProfileUpdate(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do135(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do135(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchUserProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82334,12 +83030,12 @@ var init_userProfileUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/userProfileUpdate.ts
-var args123, tool$userProfileUpdate;
+var args127, tool$userProfileUpdate;
 var init_userProfileUpdate2 = __esm(() => {
   init_userProfileUpdate();
   init_operations();
   init_tools();
-  args123 = {
+  args127 = {
     request: PatchUserProfileRequest$inboundSchema
   };
   tool$userProfileUpdate = {
@@ -82348,9 +83044,9 @@ var init_userProfileUpdate2 = __esm(() => {
 
 Update the current user profile
 `,
-    args: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await userProfileUpdate(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await userProfileUpdate(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82365,9 +83061,9 @@ Update the current user profile
 
 // src/funcs/virtualMachineBackupsCreate.ts
 function virtualMachineBackupsCreate(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse4(request, (value) => VirtualMachineBackupPayload$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82443,12 +83139,12 @@ var init_virtualMachineBackupsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineBackupsCreate.ts
-var args124, tool$virtualMachineBackupsCreate;
+var args128, tool$virtualMachineBackupsCreate;
 var init_virtualMachineBackupsCreate2 = __esm(() => {
   init_virtualMachineBackupsCreate();
   init_models();
   init_tools();
-  args124 = {
+  args128 = {
     request: VirtualMachineBackupPayload$inboundSchema
   };
   tool$virtualMachineBackupsCreate = {
@@ -82457,9 +83153,9 @@ var init_virtualMachineBackupsCreate2 = __esm(() => {
 
 Triggers a backup of the Virtual Machine referenced in the body.
 `,
-    args: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await virtualMachineBackupsCreate(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsCreate(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82474,9 +83170,9 @@ Triggers a backup of the Virtual Machine referenced in the body.
 
 // src/funcs/virtualMachineBackupsCreateForVirtualMachine.ts
 function virtualMachineBackupsCreateForVirtualMachine(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82555,12 +83251,12 @@ var init_virtualMachineBackupsCreateForVirtualMachine = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineBackupsCreateForVirtualMachine.ts
-var args125, tool$virtualMachineBackupsCreateForVirtualMachine;
+var args129, tool$virtualMachineBackupsCreateForVirtualMachine;
 var init_virtualMachineBackupsCreateForVirtualMachine2 = __esm(() => {
   init_virtualMachineBackupsCreateForVirtualMachine();
   init_operations();
   init_tools();
-  args125 = {
+  args129 = {
     request: CreateVirtualMachineBackupRequest$inboundSchema
   };
   tool$virtualMachineBackupsCreateForVirtualMachine = {
@@ -82569,9 +83265,9 @@ var init_virtualMachineBackupsCreateForVirtualMachine2 = __esm(() => {
 
 Triggers a backup of the given Virtual Machine.
 `,
-    args: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await virtualMachineBackupsCreateForVirtualMachine(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsCreateForVirtualMachine(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82586,9 +83282,9 @@ Triggers a backup of the given Virtual Machine.
 
 // src/funcs/virtualMachineBackupsDelete.ts
 function virtualMachineBackupsDelete(client, request, options) {
-  return new APIPromise($do134(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do134(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82670,12 +83366,12 @@ var init_virtualMachineBackupsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineBackupsDelete.ts
-var args126, tool$virtualMachineBackupsDelete;
+var args130, tool$virtualMachineBackupsDelete;
 var init_virtualMachineBackupsDelete2 = __esm(() => {
   init_virtualMachineBackupsDelete();
   init_operations();
   init_tools();
-  args126 = {
+  args130 = {
     request: DeleteVirtualMachineBackupRequest$inboundSchema
   };
   tool$virtualMachineBackupsDelete = {
@@ -82684,9 +83380,9 @@ var init_virtualMachineBackupsDelete2 = __esm(() => {
 
 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: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await virtualMachineBackupsDelete(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsDelete(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82701,9 +83397,9 @@ Archives and deletes a Virtual Machine backup. Work runs asynchronously and retu
 
 // src/funcs/virtualMachineBackupsGet.ts
 function virtualMachineBackupsGet(client, request, options) {
-  return new APIPromise($do135(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do135(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualMachineBackupRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82785,20 +83481,20 @@ var init_virtualMachineBackupsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineBackupsGet.ts
-var args127, tool$virtualMachineBackupsGet;
+var args131, tool$virtualMachineBackupsGet;
 var init_virtualMachineBackupsGet2 = __esm(() => {
   init_virtualMachineBackupsGet();
   init_operations();
   init_tools();
-  args127 = {
+  args131 = {
     request: GetVirtualMachineBackupRequest$inboundSchema
   };
   tool$virtualMachineBackupsGet = {
     name: "virtual-machine-backups-get",
     description: `Get VM backup`,
-    args: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await virtualMachineBackupsGet(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsGet(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -82813,9 +83509,9 @@ var init_virtualMachineBackupsGet2 = __esm(() => {
 
 // src/funcs/virtualMachineBackupsList.ts
 function virtualMachineBackupsList(client, options) {
-  return new APIPromise($do136(client, options));
+  return new APIPromise($do140(client, options));
 }
-async function $do136(client, options) {
+async function $do140(client, options) {
   const path = pathToFunc("/virtual_machine_backups")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -82907,9 +83603,9 @@ Lists every backup that belongs to the authenticated team.
 
 // src/funcs/virtualMachineBackupsListForVirtualMachine.ts
 function virtualMachineBackupsListForVirtualMachine(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVirtualMachineScopedBackupsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -82988,12 +83684,12 @@ var init_virtualMachineBackupsListForVirtualMachine = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineBackupsListForVirtualMachine.ts
-var args128, tool$virtualMachineBackupsListForVirtualMachine;
+var args132, tool$virtualMachineBackupsListForVirtualMachine;
 var init_virtualMachineBackupsListForVirtualMachine2 = __esm(() => {
   init_virtualMachineBackupsListForVirtualMachine();
   init_operations();
   init_tools();
-  args128 = {
+  args132 = {
     request: ListVirtualMachineScopedBackupsRequest$inboundSchema
   };
   tool$virtualMachineBackupsListForVirtualMachine = {
@@ -83002,9 +83698,9 @@ var init_virtualMachineBackupsListForVirtualMachine2 = __esm(() => {
 
 Lists the backups of the given Virtual Machine.
 `,
-    args: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await virtualMachineBackupsListForVirtualMachine(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await virtualMachineBackupsListForVirtualMachine(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83019,9 +83715,9 @@ Lists the backups of the given Virtual Machine.
 
 // src/funcs/virtualMachineRestoresCreate.ts
 function virtualMachineRestoresCreate(client, request, options) {
-  return new APIPromise($do138(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do138(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse4(request, (value) => VirtualMachineRestorePayload$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83097,12 +83793,12 @@ var init_virtualMachineRestoresCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineRestoresCreate.ts
-var args129, tool$virtualMachineRestoresCreate;
+var args133, tool$virtualMachineRestoresCreate;
 var init_virtualMachineRestoresCreate2 = __esm(() => {
   init_virtualMachineRestoresCreate();
   init_models();
   init_tools();
-  args129 = {
+  args133 = {
     request: VirtualMachineRestorePayload$inboundSchema
   };
   tool$virtualMachineRestoresCreate = {
@@ -83111,9 +83807,9 @@ var init_virtualMachineRestoresCreate2 = __esm(() => {
 
 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: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await virtualMachineRestoresCreate(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresCreate(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83128,9 +83824,9 @@ Restores the backup referenced in the body into a new Virtual Machine. Optionall
 
 // src/funcs/virtualMachineRestoresCreateForVirtualMachineBackup.ts
 function virtualMachineRestoresCreateForVirtualMachineBackup(client, request, options) {
-  return new APIPromise($do139(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do139(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVirtualMachineRestoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83216,12 +83912,12 @@ var init_virtualMachineRestoresCreateForVirtualMachineBackup = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineRestoresCreateForVirtualMachineBackup.ts
-var args130, tool$virtualMachineRestoresCreateForVirtualMachineBackup;
+var args134, tool$virtualMachineRestoresCreateForVirtualMachineBackup;
 var init_virtualMachineRestoresCreateForVirtualMachineBackup2 = __esm(() => {
   init_virtualMachineRestoresCreateForVirtualMachineBackup();
   init_operations();
   init_tools();
-  args130 = {
+  args134 = {
     request: CreateVirtualMachineRestoreRequest$inboundSchema
   };
   tool$virtualMachineRestoresCreateForVirtualMachineBackup = {
@@ -83230,9 +83926,9 @@ var init_virtualMachineRestoresCreateForVirtualMachineBackup2 = __esm(() => {
 
 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: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await virtualMachineRestoresCreateForVirtualMachineBackup(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresCreateForVirtualMachineBackup(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83247,9 +83943,9 @@ Restores a backup into a new Virtual Machine. Optionally accepts a \`name\` for
 
 // src/funcs/virtualMachineRestoresGet.ts
 function virtualMachineRestoresGet(client, request, options) {
-  return new APIPromise($do140(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do140(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVirtualMachineRestoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83331,20 +84027,20 @@ var init_virtualMachineRestoresGet = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineRestoresGet.ts
-var args131, tool$virtualMachineRestoresGet;
+var args135, tool$virtualMachineRestoresGet;
 var init_virtualMachineRestoresGet2 = __esm(() => {
   init_virtualMachineRestoresGet();
   init_operations();
   init_tools();
-  args131 = {
+  args135 = {
     request: GetVirtualMachineRestoreRequest$inboundSchema
   };
   tool$virtualMachineRestoresGet = {
     name: "virtual-machine-restores-get",
     description: `Get VM restore`,
-    args: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await virtualMachineRestoresGet(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresGet(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83359,9 +84055,9 @@ var init_virtualMachineRestoresGet2 = __esm(() => {
 
 // src/funcs/virtualMachineRestoresList.ts
 function virtualMachineRestoresList(client, options) {
-  return new APIPromise($do141(client, options));
+  return new APIPromise($do145(client, options));
 }
-async function $do141(client, options) {
+async function $do145(client, options) {
   const path = pathToFunc("/virtual_machine_restores")();
   const headers = new Headers(compactMap({
     Accept: "application/vnd.api+json"
@@ -83453,9 +84149,9 @@ Lists every restore that belongs to the authenticated team.
 
 // src/funcs/virtualMachineRestoresListForBackup.ts
 function virtualMachineRestoresListForBackup(client, request, options) {
-  return new APIPromise($do142(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do142(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse4(request, (value) => ListBackupRestoresRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83537,12 +84233,12 @@ var init_virtualMachineRestoresListForBackup = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineRestoresListForBackup.ts
-var args132, tool$virtualMachineRestoresListForBackup;
+var args136, tool$virtualMachineRestoresListForBackup;
 var init_virtualMachineRestoresListForBackup2 = __esm(() => {
   init_virtualMachineRestoresListForBackup();
   init_operations();
   init_tools();
-  args132 = {
+  args136 = {
     request: ListBackupRestoresRequest$inboundSchema
   };
   tool$virtualMachineRestoresListForBackup = {
@@ -83551,9 +84247,9 @@ var init_virtualMachineRestoresListForBackup2 = __esm(() => {
 
 Lists the restores created from the given backup, reached via the top-level backup path.
 `,
-    args: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await virtualMachineRestoresListForBackup(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresListForBackup(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83568,9 +84264,9 @@ Lists the restores created from the given backup, reached via the top-level back
 
 // src/funcs/virtualMachineRestoresListForVirtualMachineBackup.ts
 function virtualMachineRestoresListForVirtualMachineBackup(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do147(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do147(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVirtualMachineScopedRestoresRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83653,12 +84349,12 @@ var init_virtualMachineRestoresListForVirtualMachineBackup = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachineRestoresListForVirtualMachineBackup.ts
-var args133, tool$virtualMachineRestoresListForVirtualMachineBackup;
+var args137, tool$virtualMachineRestoresListForVirtualMachineBackup;
 var init_virtualMachineRestoresListForVirtualMachineBackup2 = __esm(() => {
   init_virtualMachineRestoresListForVirtualMachineBackup();
   init_operations();
   init_tools();
-  args133 = {
+  args137 = {
     request: ListVirtualMachineScopedRestoresRequest$inboundSchema
   };
   tool$virtualMachineRestoresListForVirtualMachineBackup = {
@@ -83667,9 +84363,9 @@ var init_virtualMachineRestoresListForVirtualMachineBackup2 = __esm(() => {
 
 Lists the restores created from the given backup.
 `,
-    args: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await virtualMachineRestoresListForVirtualMachineBackup(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await virtualMachineRestoresListForVirtualMachineBackup(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83684,9 +84380,9 @@ Lists the restores created from the given backup.
 
 // src/funcs/virtualMachinesCreate.ts
 function virtualMachinesCreate(client, request, options) {
-  return new APIPromise($do144(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do144(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse4(request, (value) => VirtualMachinePayload$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83756,12 +84452,12 @@ var init_virtualMachinesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesCreate.ts
-var args134, tool$virtualMachinesCreate;
+var args138, tool$virtualMachinesCreate;
 var init_virtualMachinesCreate2 = __esm(() => {
   init_virtualMachinesCreate();
   init_models();
   init_tools();
-  args134 = {
+  args138 = {
     request: VirtualMachinePayload$inboundSchema
   };
   tool$virtualMachinesCreate = {
@@ -83770,9 +84466,9 @@ var init_virtualMachinesCreate2 = __esm(() => {
 
 Creates a new Virtual Machine.
 `,
-    args: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreate(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreate(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83787,9 +84483,9 @@ Creates a new Virtual Machine.
 
 // src/funcs/virtualMachinesCreateVirtualMachineAction.ts
 function virtualMachinesCreateVirtualMachineAction(client, request, options) {
-  return new APIPromise($do145(client, request, options));
+  return new APIPromise($do149(client, request, options));
 }
-async function $do145(client, request, options) {
+async function $do149(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVirtualMachineActionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83861,12 +84557,12 @@ var init_virtualMachinesCreateVirtualMachineAction = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesCreateVirtualMachineAction.ts
-var args135, tool$virtualMachinesCreateVirtualMachineAction;
+var args139, tool$virtualMachinesCreateVirtualMachineAction;
 var init_virtualMachinesCreateVirtualMachineAction2 = __esm(() => {
   init_virtualMachinesCreateVirtualMachineAction();
   init_operations();
   init_tools();
-  args135 = {
+  args139 = {
     request: CreateVirtualMachineActionRequest$inboundSchema
   };
   tool$virtualMachinesCreateVirtualMachineAction = {
@@ -83878,9 +84574,9 @@ Performs a power action on a given virtual machine:
 - \`power_off\` - Stops the virtual machine
 - \`reboot\` - Restarts the virtual machine
 `,
-    args: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreateVirtualMachineAction(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreateVirtualMachineAction(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83894,9 +84590,9 @@ Performs a power action on a given virtual machine:
 
 // src/funcs/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
 function virtualMachinesCreateVirtualMachineNetworkAttachment(client, request, options) {
-  return new APIPromise($do146(client, request, options));
+  return new APIPromise($do150(client, request, options));
 }
-async function $do146(client, request, options) {
+async function $do150(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -83967,12 +84663,12 @@ var init_virtualMachinesCreateVirtualMachineNetworkAttachment = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesCreateVirtualMachineNetworkAttachment.ts
-var args136, tool$virtualMachinesCreateVirtualMachineNetworkAttachment;
+var args140, tool$virtualMachinesCreateVirtualMachineNetworkAttachment;
 var init_virtualMachinesCreateVirtualMachineNetworkAttachment2 = __esm(() => {
   init_virtualMachinesCreateVirtualMachineNetworkAttachment();
   init_operations();
   init_tools();
-  args136 = {
+  args140 = {
     request: CreateVirtualMachineNetworkAttachmentRequest$inboundSchema
   };
   tool$virtualMachinesCreateVirtualMachineNetworkAttachment = {
@@ -83981,9 +84677,9 @@ var init_virtualMachinesCreateVirtualMachineNetworkAttachment2 = __esm(() => {
 
 Attaches a virtual network (VLAN) to a Virtual Machine. Work runs asynchronously and returns 202 Accepted.
 `,
-    args: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await virtualMachinesCreateVirtualMachineNetworkAttachment(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await virtualMachinesCreateVirtualMachineNetworkAttachment(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -83998,9 +84694,9 @@ Attaches a virtual network (VLAN) to a Virtual Machine. Work runs asynchronously
 
 // src/funcs/virtualMachinesDelete.ts
 function virtualMachinesDelete(client, request, options) {
-  return new APIPromise($do147(client, request, options));
+  return new APIPromise($do151(client, request, options));
 }
-async function $do147(client, request, options) {
+async function $do151(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84071,12 +84767,12 @@ var init_virtualMachinesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesDelete.ts
-var args137, tool$virtualMachinesDelete;
+var args141, tool$virtualMachinesDelete;
 var init_virtualMachinesDelete2 = __esm(() => {
   init_virtualMachinesDelete();
   init_operations();
   init_tools();
-  args137 = {
+  args141 = {
     request: DestroyVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesDelete = {
@@ -84085,9 +84781,9 @@ var init_virtualMachinesDelete2 = __esm(() => {
 
 Destroys a Virtual Machine.
 `,
-    args: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await virtualMachinesDelete(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await virtualMachinesDelete(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84101,9 +84797,9 @@ Destroys a Virtual Machine.
 
 // src/funcs/virtualMachinesDestroyVirtualMachineNetworkAttachment.ts
 function virtualMachinesDestroyVirtualMachineNetworkAttachment(client, request, options) {
-  return new APIPromise($do148(client, request, options));
+  return new APIPromise($do152(client, request, options));
 }
-async function $do148(client, request, options) {
+async function $do152(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyVirtualMachineNetworkAttachmentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84177,12 +84873,12 @@ var init_virtualMachinesDestroyVirtualMachineNetworkAttachment = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesDestroyVirtualMachineNetworkAttachment.ts
-var args138, tool$virtualMachinesDestroyVirtualMachineNetworkAttachment;
+var args142, tool$virtualMachinesDestroyVirtualMachineNetworkAttachment;
 var init_virtualMachinesDestroyVirtualMachineNetworkAttachment2 = __esm(() => {
   init_virtualMachinesDestroyVirtualMachineNetworkAttachment();
   init_operations();
   init_tools();
-  args138 = {
+  args142 = {
     request: DestroyVirtualMachineNetworkAttachmentRequest$inboundSchema
   };
   tool$virtualMachinesDestroyVirtualMachineNetworkAttachment = {
@@ -84191,9 +84887,9 @@ var init_virtualMachinesDestroyVirtualMachineNetworkAttachment2 = __esm(() => {
 
 Detaches a virtual network (VLAN) from a Virtual Machine. Work runs asynchronously and returns 202 Accepted.
 `,
-    args: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await virtualMachinesDestroyVirtualMachineNetworkAttachment(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await virtualMachinesDestroyVirtualMachineNetworkAttachment(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84208,9 +84904,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($do149(client, request, options));
+  return new APIPromise($do153(client, request, options));
 }
-async function $do149(client, request, options) {
+async function $do153(client, request, options) {
   const parsed = safeParse4(request, (value) => ShowVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84287,12 +84983,12 @@ var init_virtualMachinesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesGet.ts
-var args139, tool$virtualMachinesGet;
+var args143, tool$virtualMachinesGet;
 var init_virtualMachinesGet2 = __esm(() => {
   init_virtualMachinesGet();
   init_operations();
   init_tools();
-  args139 = {
+  args143 = {
     request: ShowVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesGet = {
@@ -84301,9 +84997,9 @@ var init_virtualMachinesGet2 = __esm(() => {
 
 Show a Virtual Machine.
 `,
-    args: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await virtualMachinesGet(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await virtualMachinesGet(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84318,9 +85014,9 @@ Show a Virtual Machine.
 
 // src/funcs/virtualMachinesList.ts
 function virtualMachinesList(client, request, options) {
-  return new APIPromise($do150(client, request, options));
+  return new APIPromise($do154(client, request, options));
 }
-async function $do150(client, request, options) {
+async function $do154(client, request, options) {
   const parsed = safeParse4(request, (value) => IndexVirtualMachineRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -84436,12 +85132,12 @@ var init_virtualMachinesList = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesList.ts
-var args140, tool$virtualMachinesList;
+var args144, tool$virtualMachinesList;
 var init_virtualMachinesList2 = __esm(() => {
   init_virtualMachinesList();
   init_operations();
   init_tools();
-  args140 = {
+  args144 = {
     request: IndexVirtualMachineRequest$inboundSchema.optional()
   };
   tool$virtualMachinesList = {
@@ -84450,9 +85146,9 @@ var init_virtualMachinesList2 = __esm(() => {
 
 Show all Team's Virtual Machines.
 `,
-    args: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await virtualMachinesList(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await virtualMachinesList(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84467,9 +85163,9 @@ Show all Team's Virtual Machines.
 
 // src/funcs/virtualMachinesListVirtualMachineNetworkAttachments.ts
 function virtualMachinesListVirtualMachineNetworkAttachments(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do155(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do155(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVirtualMachineNetworkAttachmentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84542,12 +85238,12 @@ var init_virtualMachinesListVirtualMachineNetworkAttachments = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesListVirtualMachineNetworkAttachments.ts
-var args141, tool$virtualMachinesListVirtualMachineNetworkAttachments;
+var args145, tool$virtualMachinesListVirtualMachineNetworkAttachments;
 var init_virtualMachinesListVirtualMachineNetworkAttachments2 = __esm(() => {
   init_virtualMachinesListVirtualMachineNetworkAttachments();
   init_operations();
   init_tools();
-  args141 = {
+  args145 = {
     request: ListVirtualMachineNetworkAttachmentsRequest$inboundSchema
   };
   tool$virtualMachinesListVirtualMachineNetworkAttachments = {
@@ -84556,9 +85252,9 @@ var init_virtualMachinesListVirtualMachineNetworkAttachments2 = __esm(() => {
 
 Lists the secondary network attachments currently configured for a Virtual Machine.
 `,
-    args: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await virtualMachinesListVirtualMachineNetworkAttachments(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await virtualMachinesListVirtualMachineNetworkAttachments(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84573,9 +85269,9 @@ Lists the secondary network attachments currently configured for a Virtual Machi
 
 // src/funcs/virtualMachinesShowVirtualMachineMetrics.ts
 function virtualMachinesShowVirtualMachineMetrics(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do156(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do156(client, request, options) {
   const parsed = safeParse4(request, (value) => ShowVirtualMachineMetricsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84654,12 +85350,12 @@ var init_virtualMachinesShowVirtualMachineMetrics = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesShowVirtualMachineMetrics.ts
-var args142, tool$virtualMachinesShowVirtualMachineMetrics;
+var args146, tool$virtualMachinesShowVirtualMachineMetrics;
 var init_virtualMachinesShowVirtualMachineMetrics2 = __esm(() => {
   init_virtualMachinesShowVirtualMachineMetrics();
   init_operations();
   init_tools();
-  args142 = {
+  args146 = {
     request: ShowVirtualMachineMetricsRequest$inboundSchema
   };
   tool$virtualMachinesShowVirtualMachineMetrics = {
@@ -84667,9 +85363,9 @@ var init_virtualMachinesShowVirtualMachineMetrics2 = __esm(() => {
     description: `Retrieve VM metrics
 
 Retrieve a time series for a single metric of a Virtual Machine.`,
-    args: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await virtualMachinesShowVirtualMachineMetrics(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await virtualMachinesShowVirtualMachineMetrics(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84684,9 +85380,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($do153(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVirtualMachineRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84762,12 +85458,12 @@ var init_virtualMachinesUpdateVirtualMachine = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualMachinesUpdateVirtualMachine.ts
-var args143, tool$virtualMachinesUpdateVirtualMachine;
+var args147, tool$virtualMachinesUpdateVirtualMachine;
 var init_virtualMachinesUpdateVirtualMachine2 = __esm(() => {
   init_virtualMachinesUpdateVirtualMachine();
   init_operations();
   init_tools();
-  args143 = {
+  args147 = {
     request: UpdateVirtualMachineRequest$inboundSchema
   };
   tool$virtualMachinesUpdateVirtualMachine = {
@@ -84776,9 +85472,9 @@ var init_virtualMachinesUpdateVirtualMachine2 = __esm(() => {
 
 Updates a Virtual Machine's display name (hostname).
 `,
-    args: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await virtualMachinesUpdateVirtualMachine(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await virtualMachinesUpdateVirtualMachine(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84793,9 +85489,9 @@ Updates a Virtual Machine's display name (hostname).
 
 // src/funcs/virtualNetworksDelete.ts
 function virtualNetworksDelete(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse4(request, (value) => DestroyVirtualNetworkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84869,12 +85565,12 @@ var init_virtualNetworksDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/virtualNetworksDelete.ts
-var args144, tool$virtualNetworksDelete;
+var args148, tool$virtualNetworksDelete;
 var init_virtualNetworksDelete2 = __esm(() => {
   init_virtualNetworksDelete();
   init_operations();
   init_tools();
-  args144 = {
+  args148 = {
     request: DestroyVirtualNetworkRequest$inboundSchema
   };
   tool$virtualNetworksDelete = {
@@ -84883,9 +85579,9 @@ var init_virtualNetworksDelete2 = __esm(() => {
 
 Delete virtual network
 `,
-    args: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await virtualNetworksDelete(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await virtualNetworksDelete(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -84899,9 +85595,9 @@ Delete virtual network
 
 // src/funcs/vpnSessionsCreate.ts
 function vpnSessionsCreate(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse4(request, (value) => PostVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -84972,12 +85668,12 @@ var init_vpnSessionsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsCreate.ts
-var args145, tool$vpnSessionsCreate;
+var args149, tool$vpnSessionsCreate;
 var init_vpnSessionsCreate2 = __esm(() => {
   init_vpnSessionsCreate();
   init_operations();
   init_tools();
-  args145 = {
+  args149 = {
     request: PostVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsCreate = {
@@ -84987,9 +85683,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await vpnSessionsCreate(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await vpnSessionsCreate(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -85004,9 +85700,9 @@ Creates a new VPN Session.
 
 // src/funcs/vpnSessionsDelete.ts
 function vpnSessionsDelete(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do160(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do160(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -85080,12 +85776,12 @@ var init_vpnSessionsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsDelete.ts
-var args146, tool$vpnSessionsDelete;
+var args150, tool$vpnSessionsDelete;
 var init_vpnSessionsDelete2 = __esm(() => {
   init_vpnSessionsDelete();
   init_operations();
   init_tools();
-  args146 = {
+  args150 = {
     request: DeleteVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsDelete = {
@@ -85094,9 +85790,9 @@ var init_vpnSessionsDelete2 = __esm(() => {
 
 Deletes an existing VPN Session.
 `,
-    args: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await vpnSessionsDelete(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await vpnSessionsDelete(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -85110,9 +85806,9 @@ Deletes an existing VPN Session.
 
 // src/funcs/vpnSessionsList.ts
 function vpnSessionsList(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do161(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do161(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVpnSessionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -85185,20 +85881,20 @@ var init_vpnSessionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsList.ts
-var args147, tool$vpnSessionsList;
+var args151, tool$vpnSessionsList;
 var init_vpnSessionsList2 = __esm(() => {
   init_vpnSessionsList();
   init_operations();
   init_tools();
-  args147 = {
+  args151 = {
     request: GetVpnSessionsRequest$inboundSchema.optional()
   };
   tool$vpnSessionsList = {
     name: "vpn-sessions-list",
     description: `List VPN sessions`,
-    args: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await vpnSessionsList(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await vpnSessionsList(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -85213,9 +85909,9 @@ var init_vpnSessionsList2 = __esm(() => {
 
 // src/funcs/vpnSessionsRefreshPassword.ts
 function vpnSessionsRefreshPassword(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do162(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do162(client, request, options) {
   const parsed = safeParse4(request, (value) => PutVpnSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -85291,12 +85987,12 @@ var init_vpnSessionsRefreshPassword = __esm(() => {
 });
 
 // src/mcp-server/tools/vpnSessionsRefreshPassword.ts
-var args148, tool$vpnSessionsRefreshPassword;
+var args152, tool$vpnSessionsRefreshPassword;
 var init_vpnSessionsRefreshPassword2 = __esm(() => {
   init_vpnSessionsRefreshPassword();
   init_operations();
   init_tools();
-  args148 = {
+  args152 = {
     request: PutVpnSessionRequest$inboundSchema
   };
   tool$vpnSessionsRefreshPassword = {
@@ -85305,9 +86001,9 @@ var init_vpnSessionsRefreshPassword2 = __esm(() => {
 
 Refreshing an existing VPN Session will create new credentials for that session
 `,
-    args: args148,
-    tool: async (client, args149, ctx) => {
-      const [result, apiCall] = await vpnSessionsRefreshPassword(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args152,
+    tool: async (client, args153, ctx) => {
+      const [result, apiCall] = await vpnSessionsRefreshPassword(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -85324,7 +86020,7 @@ Refreshing an existing VPN Session will create new credentials for that session
 function createMCPServer(deps) {
   const server2 = new McpServer({
     name: "Latitudesh",
-    version: "0.8.6"
+    version: "0.8.7"
   });
   const client = new LatitudeshCore({
     bearer: deps.bearer,
@@ -85388,6 +86084,10 @@ function createMCPServer(deps) {
   tool(tool$plansUpdateBandwidth);
   tool(tool$plansListStorage);
   tool(tool$plansGetManagedDatabasePlans);
+  tool(tool$prefixesGetPrefixes);
+  tool(tool$prefixesCreatePrefix);
+  tool(tool$prefixesGetPrefix);
+  tool(tool$prefixesDestroyPrefix);
   tool(tool$projectsList);
   tool(tool$projectsCreate);
   tool(tool$projectsUpdate);
@@ -85567,6 +86267,10 @@ var init_server4 = __esm(() => {
   init_plansListStorage2();
   init_plansUpdateBandwidth2();
   init_plansVmList2();
+  init_prefixesCreatePrefix2();
+  init_prefixesDestroyPrefix2();
+  init_prefixesGetPrefix2();
+  init_prefixesGetPrefixes2();
   init_privateNetworksAssign2();
   init_privateNetworksCreate2();
   init_privateNetworksDeleteAssignment2();
@@ -86865,7 +87569,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.8.6"
+    currentVersion: "0.8.7"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -86873,5 +87577,5 @@ export {
   app
 };
 
-//# debugId=C01F5B27F55772A364756E2164756E21
+//# debugId=39ED2B41718AF1CE64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map