latitudesh-typescript-sdk 0.8.29 → 0.8.31

package/src/models/updatepublicnetworkip.ts

@@ -0,0 +1,172 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const UpdatePublicNetworkIpType = {
+  PublicNetworks: "public_networks",
+} as const;
+export type UpdatePublicNetworkIpType = ClosedEnum<
+  typeof UpdatePublicNetworkIpType
+>;
+
+export type UpdatePublicNetworkIpAttributes = {
+  /**
+   * The IPv4 address, e.g. 203.0.113.4
+   */
+  address: string;
+  /**
+   * true reserves an available address so servers are never attached with it; false releases an address you reserved
+   */
+  reserved: boolean;
+};
+
+export type UpdatePublicNetworkIpData = {
+  type: UpdatePublicNetworkIpType;
+  attributes?: UpdatePublicNetworkIpAttributes | undefined;
+};
+
+export type UpdatePublicNetworkIp = {
+  data: UpdatePublicNetworkIpData;
+};
+
+/** @internal */
+export const UpdatePublicNetworkIpType$inboundSchema: z.ZodNativeEnum<
+  typeof UpdatePublicNetworkIpType
+> = z.nativeEnum(UpdatePublicNetworkIpType);
+/** @internal */
+export const UpdatePublicNetworkIpType$outboundSchema: z.ZodNativeEnum<
+  typeof UpdatePublicNetworkIpType
+> = UpdatePublicNetworkIpType$inboundSchema;
+
+/** @internal */
+export const UpdatePublicNetworkIpAttributes$inboundSchema: z.ZodType<
+  UpdatePublicNetworkIpAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  address: z.string(),
+  reserved: z.boolean(),
+});
+/** @internal */
+export type UpdatePublicNetworkIpAttributes$Outbound = {
+  address: string;
+  reserved: boolean;
+};
+
+/** @internal */
+export const UpdatePublicNetworkIpAttributes$outboundSchema: z.ZodType<
+  UpdatePublicNetworkIpAttributes$Outbound,
+  z.ZodTypeDef,
+  UpdatePublicNetworkIpAttributes
+> = z.object({
+  address: z.string(),
+  reserved: z.boolean(),
+});
+
+export function updatePublicNetworkIpAttributesToJSON(
+  updatePublicNetworkIpAttributes: UpdatePublicNetworkIpAttributes,
+): string {
+  return JSON.stringify(
+    UpdatePublicNetworkIpAttributes$outboundSchema.parse(
+      updatePublicNetworkIpAttributes,
+    ),
+  );
+}
+export function updatePublicNetworkIpAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePublicNetworkIpAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePublicNetworkIpAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePublicNetworkIpAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdatePublicNetworkIpData$inboundSchema: z.ZodType<
+  UpdatePublicNetworkIpData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: UpdatePublicNetworkIpType$inboundSchema,
+  attributes: z.lazy(() => UpdatePublicNetworkIpAttributes$inboundSchema)
+    .optional(),
+});
+/** @internal */
+export type UpdatePublicNetworkIpData$Outbound = {
+  type: string;
+  attributes?: UpdatePublicNetworkIpAttributes$Outbound | undefined;
+};
+
+/** @internal */
+export const UpdatePublicNetworkIpData$outboundSchema: z.ZodType<
+  UpdatePublicNetworkIpData$Outbound,
+  z.ZodTypeDef,
+  UpdatePublicNetworkIpData
+> = z.object({
+  type: UpdatePublicNetworkIpType$outboundSchema,
+  attributes: z.lazy(() => UpdatePublicNetworkIpAttributes$outboundSchema)
+    .optional(),
+});
+
+export function updatePublicNetworkIpDataToJSON(
+  updatePublicNetworkIpData: UpdatePublicNetworkIpData,
+): string {
+  return JSON.stringify(
+    UpdatePublicNetworkIpData$outboundSchema.parse(updatePublicNetworkIpData),
+  );
+}
+export function updatePublicNetworkIpDataFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePublicNetworkIpData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePublicNetworkIpData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePublicNetworkIpData' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdatePublicNetworkIp$inboundSchema: z.ZodType<
+  UpdatePublicNetworkIp,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => UpdatePublicNetworkIpData$inboundSchema),
+});
+/** @internal */
+export type UpdatePublicNetworkIp$Outbound = {
+  data: UpdatePublicNetworkIpData$Outbound;
+};
+
+/** @internal */
+export const UpdatePublicNetworkIp$outboundSchema: z.ZodType<
+  UpdatePublicNetworkIp$Outbound,
+  z.ZodTypeDef,
+  UpdatePublicNetworkIp
+> = z.object({
+  data: z.lazy(() => UpdatePublicNetworkIpData$outboundSchema),
+});
+
+export function updatePublicNetworkIpToJSON(
+  updatePublicNetworkIp: UpdatePublicNetworkIp,
+): string {
+  return JSON.stringify(
+    UpdatePublicNetworkIp$outboundSchema.parse(updatePublicNetworkIp),
+  );
+}
+export function updatePublicNetworkIpFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePublicNetworkIp, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePublicNetworkIp$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePublicNetworkIp' from JSON`,
+  );
+}

package/src/models/virtualmachineattributes.ts

@@ -181,6 +181,10 @@ export type VirtualMachineAttributesAttributes = {
   tags?: Array<VirtualMachineAttributesTag> | undefined;
   team?: TeamInclude | undefined;
   project?: ProjectInclude | undefined;
+  /**
+   * Whether the VM re-applies the platform network configuration on every boot. Set at creation; false for VMs created before this option was available. When false, configure networks attached to the VM inside the guest yourself, as described in [Private networks: configure the OS](https://www.latitude.sh/docs/networking/private-networks#step-3-configure-the-os).
+   */
+  applyNetworkOnBoot?: boolean | undefined;
   /**
    * Deprecated, always false. Opt-in extra field, requested via `extra_fields[virtual_machines]=pending_restart`. Attaching and detaching restart the VM automatically.
    */
@@ -733,6 +737,7 @@ export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
     .optional(),
   team: TeamInclude$inboundSchema.optional(),
   project: ProjectInclude$inboundSchema.optional(),
+  apply_network_on_boot: z.boolean().optional(),
   pending_restart: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -741,6 +746,7 @@ export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
     "operating_system": "operatingSystem",
     "user_data": "userData",
     "marketplace_app": "marketplaceApp",
+    "apply_network_on_boot": "applyNetworkOnBoot",
     "pending_restart": "pendingRestart",
   });
 });
@@ -767,6 +773,7 @@ export type VirtualMachineAttributesAttributes$Outbound = {
   tags?: Array<VirtualMachineAttributesTag$Outbound> | undefined;
   team?: TeamInclude$Outbound | undefined;
   project?: ProjectInclude$Outbound | undefined;
+  apply_network_on_boot?: boolean | undefined;
   pending_restart?: boolean | undefined;
 };
 
@@ -798,6 +805,7 @@ export const VirtualMachineAttributesAttributes$outboundSchema: z.ZodType<
     .optional(),
   team: TeamInclude$outboundSchema.optional(),
   project: ProjectInclude$outboundSchema.optional(),
+  applyNetworkOnBoot: z.boolean().optional(),
   pendingRestart: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -806,6 +814,7 @@ export const VirtualMachineAttributesAttributes$outboundSchema: z.ZodType<
     operatingSystem: "operating_system",
     userData: "user_data",
     marketplaceApp: "marketplace_app",
+    applyNetworkOnBoot: "apply_network_on_boot",
     pendingRestart: "pending_restart",
   });
 });

package/src/models/virtualmachinenetworkattachmentcreatepayload.ts

@@ -22,7 +22,7 @@ export type VirtualMachineNetworkAttachmentCreatePayloadAttributes = {
    */
   virtualNetworkId: string;
   /**
-   * Optional static IPv4 address with prefix (e.g. 10.0.0.5/24) for the NIC inside the guest. When omitted the NIC is configured for DHCP without a default route. Applying the regenerated network configuration requires running `sudo cloud-init clean --logs --reboot` inside the guest. Warning: that command makes cloud-init treat the next boot as a first boot — it re-runs the instance user-data (e.g. runcmd scripts) and regenerates the SSH host keys, so SSH clients will see a host-key changed warning.
+   * Optional static IPv4 address with prefix (e.g. 10.0.0.5/24) for the NIC inside the guest. When omitted the NIC is configured for DHCP without a default route. VMs created with `apply_network_on_boot` enabled apply it on the restart the attach performs; on other VMs, configure it yourself on the interface whose MAC matches the attachment `mac_address`.
    */
   address?: string | undefined;
 };

package/src/models/virtualmachinenetworkattachmentresource.ts

@@ -25,6 +25,14 @@ export type VirtualMachineNetworkAttachmentResourceAttributes = {
    * The 802.1Q VLAN ID
    */
   vid?: number | undefined;
+  /**
+   * The static IPv4 address with prefix given when the network was attached (e.g. 10.0.0.5/24). Null when the attachment has no static address.
+   */
+  address?: string | null | undefined;
+  /**
+   * MAC address of the NIC inside the guest. Interface names differ between images, so use the MAC to find the interface. Null until the VM has restarted with the network attached.
+   */
+  macAddress?: string | null | undefined;
   /**
    * Deprecated, always false. Attaching and detaching restart the VM automatically, so an attachment never waits on a manual restart.
    */
@@ -58,10 +66,13 @@ export const VirtualMachineNetworkAttachmentResourceAttributes$inboundSchema:
   > = z.object({
     virtual_network_id: z.string().optional(),
     vid: z.number().int().optional(),
+    address: z.nullable(z.string()).optional(),
+    mac_address: z.nullable(z.string()).optional(),
     pending_restart: z.boolean().optional(),
   }).transform((v) => {
     return remap$(v, {
       "virtual_network_id": "virtualNetworkId",
+      "mac_address": "macAddress",
       "pending_restart": "pendingRestart",
     });
   });
@@ -69,6 +80,8 @@ export const VirtualMachineNetworkAttachmentResourceAttributes$inboundSchema:
 export type VirtualMachineNetworkAttachmentResourceAttributes$Outbound = {
   virtual_network_id?: string | undefined;
   vid?: number | undefined;
+  address?: string | null | undefined;
+  mac_address?: string | null | undefined;
   pending_restart?: boolean | undefined;
 };
 
@@ -81,10 +94,13 @@ export const VirtualMachineNetworkAttachmentResourceAttributes$outboundSchema:
   > = z.object({
     virtualNetworkId: z.string().optional(),
     vid: z.number().int().optional(),
+    address: z.nullable(z.string()).optional(),
+    macAddress: z.nullable(z.string()).optional(),
     pendingRestart: z.boolean().optional(),
   }).transform((v) => {
     return remap$(v, {
       virtualNetworkId: "virtual_network_id",
+      macAddress: "mac_address",
       pendingRestart: "pending_restart",
     });
   });

package/src/models/virtualmachinepayload.ts

@@ -64,6 +64,10 @@ export type VirtualMachinePayloadAttributes = {
    * Array of tag IDs to assign to the VM.
    */
   tags?: Array<string> | null | undefined;
+  /**
+   * Re-apply the platform network configuration on every boot, so a virtual network attached to or detached from the VM is configured in the guest by the restart the attach or detach performs. Every boot, including a restart started inside the guest, rewrites cloud-init's own network file (for example `/etc/netplan/50-cloud-init.yaml`): keep custom network configuration in a separate file. Set at creation only; it cannot be changed later through the API. To stop the re-apply from inside the guest, create `/etc/cloud/cloud.cfg.d/99-disable-network-config.cfg` containing `network: {config: disabled}`; networks attached afterwards must then be configured by hand. Defaults to true.
+   */
+  applyNetworkOnBoot?: boolean | undefined;
   /**
    * Site/region slug where the VM is provisioned (e.g. DAL, SAO). Defaults to DAL when omitted.
    */
@@ -141,6 +145,7 @@ export const VirtualMachinePayloadAttributes$inboundSchema: z.ZodType<
   user_data: z.nullable(z.union([z.number().int(), z.string()])).optional(),
   marketplace_app: z.nullable(z.string()).optional(),
   tags: z.nullable(z.array(z.string())).optional(),
+  apply_network_on_boot: z.boolean().default(true),
   site: z.nullable(z.string().default("DAL")),
 }).transform((v) => {
   return remap$(v, {
@@ -148,6 +153,7 @@ export const VirtualMachinePayloadAttributes$inboundSchema: z.ZodType<
     "operating_system": "operatingSystem",
     "user_data": "userData",
     "marketplace_app": "marketplaceApp",
+    "apply_network_on_boot": "applyNetworkOnBoot",
   });
 });
 /** @internal */
@@ -161,6 +167,7 @@ export type VirtualMachinePayloadAttributes$Outbound = {
   user_data?: number | string | null | undefined;
   marketplace_app?: string | null | undefined;
   tags?: Array<string> | null | undefined;
+  apply_network_on_boot: boolean;
   site: string | null;
 };
 
@@ -179,6 +186,7 @@ export const VirtualMachinePayloadAttributes$outboundSchema: z.ZodType<
   userData: z.nullable(z.union([z.number().int(), z.string()])).optional(),
   marketplaceApp: z.nullable(z.string()).optional(),
   tags: z.nullable(z.array(z.string())).optional(),
+  applyNetworkOnBoot: z.boolean().default(true),
   site: z.nullable(z.string().default("DAL")),
 }).transform((v) => {
   return remap$(v, {
@@ -186,6 +194,7 @@ export const VirtualMachinePayloadAttributes$outboundSchema: z.ZodType<
     operatingSystem: "operating_system",
     userData: "user_data",
     marketplaceApp: "marketplace_app",
+    applyNetworkOnBoot: "apply_network_on_boot",
   });
 });
 

package/src/models/volumedata.ts

@@ -33,7 +33,7 @@ export type Initiator = {
 /**
  * Storage network the mapped server joins to reach the volume over NVMe-TCP. Null until the network has been provisioned for the volume.
  */
-export type StorageNetwork = {
+export type VolumeDataStorageNetwork = {
   /**
    * VLAN ID of the storage VLAN to tag on the server bond.
    */
@@ -83,7 +83,7 @@ export type Block = {
   /**
    * Storage network the mapped server joins to reach the volume over NVMe-TCP. Null until the network has been provisioned for the volume.
    */
-  storageNetwork?: StorageNetwork | null | undefined;
+  storageNetwork?: VolumeDataStorageNetwork | null | undefined;
 };
 
 export type VolumeDataSite = {
@@ -182,8 +182,8 @@ export function initiatorFromJSON(
 }
 
 /** @internal */
-export const StorageNetwork$inboundSchema: z.ZodType<
-  StorageNetwork,
+export const VolumeDataStorageNetwork$inboundSchema: z.ZodType<
+  VolumeDataStorageNetwork,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -201,7 +201,7 @@ export const StorageNetwork$inboundSchema: z.ZodType<
   });
 });
 /** @internal */
-export type StorageNetwork$Outbound = {
+export type VolumeDataStorageNetwork$Outbound = {
   vid?: number | null | undefined;
   host_cidr?: string | null | undefined;
   gateway?: string | null | undefined;
@@ -211,10 +211,10 @@ export type StorageNetwork$Outbound = {
 };
 
 /** @internal */
-export const StorageNetwork$outboundSchema: z.ZodType<
-  StorageNetwork$Outbound,
+export const VolumeDataStorageNetwork$outboundSchema: z.ZodType<
+  VolumeDataStorageNetwork$Outbound,
   z.ZodTypeDef,
-  StorageNetwork
+  VolumeDataStorageNetwork
 > = z.object({
   vid: z.nullable(z.number().int()).optional(),
   hostCidr: z.nullable(z.string()).optional(),
@@ -230,16 +230,20 @@ export const StorageNetwork$outboundSchema: z.ZodType<
   });
 });
 
-export function storageNetworkToJSON(storageNetwork: StorageNetwork): string {
-  return JSON.stringify(StorageNetwork$outboundSchema.parse(storageNetwork));
+export function volumeDataStorageNetworkToJSON(
+  volumeDataStorageNetwork: VolumeDataStorageNetwork,
+): string {
+  return JSON.stringify(
+    VolumeDataStorageNetwork$outboundSchema.parse(volumeDataStorageNetwork),
+  );
 }
-export function storageNetworkFromJSON(
+export function volumeDataStorageNetworkFromJSON(
   jsonString: string,
-): SafeParseResult<StorageNetwork, SDKValidationError> {
+): SafeParseResult<VolumeDataStorageNetwork, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => StorageNetwork$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'StorageNetwork' from JSON`,
+    (x) => VolumeDataStorageNetwork$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VolumeDataStorageNetwork' from JSON`,
   );
 }
 
@@ -250,8 +254,9 @@ export const Block$inboundSchema: z.ZodType<Block, z.ZodTypeDef, unknown> = z
     nqn: z.nullable(z.string()).optional(),
     nsid: z.nullable(z.number().int()).optional(),
     server_id: z.nullable(z.string()).optional(),
-    storage_network: z.nullable(z.lazy(() => StorageNetwork$inboundSchema))
-      .optional(),
+    storage_network: z.nullable(
+      z.lazy(() => VolumeDataStorageNetwork$inboundSchema),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       "server_id": "serverId",
@@ -264,7 +269,7 @@ export type Block$Outbound = {
   nqn?: string | null | undefined;
   nsid?: number | null | undefined;
   server_id?: string | null | undefined;
-  storage_network?: StorageNetwork$Outbound | null | undefined;
+  storage_network?: VolumeDataStorageNetwork$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -277,8 +282,9 @@ export const Block$outboundSchema: z.ZodType<
   nqn: z.nullable(z.string()).optional(),
   nsid: z.nullable(z.number().int()).optional(),
   serverId: z.nullable(z.string()).optional(),
-  storageNetwork: z.nullable(z.lazy(() => StorageNetwork$outboundSchema))
-    .optional(),
+  storageNetwork: z.nullable(
+    z.lazy(() => VolumeDataStorageNetwork$outboundSchema),
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
     serverId: "server_id",

package/src/sdk/blockstorage.ts

@@ -9,6 +9,7 @@ import { blockStorageMapVolume } from "../funcs/blockStorageMapVolume.js";
 import { blockStorageMountVolume } from "../funcs/blockStorageMountVolume.js";
 import { blockStorageRetrieveVolume } from "../funcs/blockStorageRetrieveVolume.js";
 import { blockStorageUnmapVolume } from "../funcs/blockStorageUnmapVolume.js";
+import { blockStorageUpdateVolume } from "../funcs/blockStorageUpdateVolume.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -82,6 +83,23 @@ export class BlockStorage extends ClientSDK {
     ));
   }
 
+  /**
+   * Update volume
+   *
+   * @remarks
+   * Increases the size of a high performance volume. Shrinking is not supported. Billing is prorated to the new size.
+   */
+  async updateVolume(
+    request: operations.UpdateVolumeRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateVolumeResponse> {
+    return unwrapAsync(blockStorageUpdateVolume(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Mount volume (deprecated)
    *

package/src/sdk/filesystemstorage.ts

@@ -2,8 +2,11 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { filesystemStorageAttachFilesystem } from "../funcs/filesystemStorageAttachFilesystem.js";
 import { filesystemStorageCreateFilesystem } from "../funcs/filesystemStorageCreateFilesystem.js";
 import { filesystemStorageDeleteFilesystem } from "../funcs/filesystemStorageDeleteFilesystem.js";
+import { filesystemStorageDetachFilesystem } from "../funcs/filesystemStorageDetachFilesystem.js";
+import { filesystemStorageGetFilesystemAttachment } from "../funcs/filesystemStorageGetFilesystemAttachment.js";
 import { filesystemStorageListFilesystems } from "../funcs/filesystemStorageListFilesystems.js";
 import { filesystemStorageUpdateFilesystem } from "../funcs/filesystemStorageUpdateFilesystem.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
@@ -19,9 +22,9 @@ export class FilesystemStorage extends ClientSDK {
    * Allows you to add persistent storage to a project. These filesystems can be used to store data across your servers.
    */
   async createFilesystem(
-    request: operations.PostStorageFilesystemsRequest,
+    request: operations.CreateFilesystemRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostStorageFilesystemsResponse> {
+  ): Promise<operations.CreateFilesystemResponse> {
     return unwrapAsync(filesystemStorageCreateFilesystem(
       this,
       request,
@@ -36,7 +39,7 @@ export class FilesystemStorage extends ClientSDK {
    * Lists all the filesystems from a team.
    */
   async listFilesystems(
-    request?: operations.GetStorageFilesystemsRequest | undefined,
+    request?: operations.ListFilesystemsRequest | undefined,
     options?: RequestOptions,
   ): Promise<models.Filesystems> {
     return unwrapAsync(filesystemStorageListFilesystems(
@@ -53,7 +56,7 @@ export class FilesystemStorage extends ClientSDK {
    * Allows you to remove a filesystem from a project.
    */
   async deleteFilesystem(
-    request: operations.DeleteStorageFilesystemsRequest,
+    request: operations.DeleteFilesystemRequest,
     options?: RequestOptions,
   ): Promise<void> {
     return unwrapAsync(filesystemStorageDeleteFilesystem(
@@ -70,13 +73,64 @@ export class FilesystemStorage extends ClientSDK {
    * Allow you to upgrade the size of a filesystem.
    */
   async updateFilesystem(
-    request: operations.PatchStorageFilesystemsRequest,
+    request: operations.UpdateFilesystemRequest,
     options?: RequestOptions,
-  ): Promise<operations.PatchStorageFilesystemsResponse> {
+  ): Promise<operations.UpdateFilesystemResponse> {
     return unwrapAsync(filesystemStorageUpdateFilesystem(
       this,
       request,
       options,
     ));
   }
+
+  /**
+   * Get filesystem attachment
+   *
+   * @remarks
+   * Returns whether a server is attached to the storage network the filesystem is served on. Poll it after attaching: once the status is "attached", configure the returned storage network on the server and mount the filesystem.
+   */
+  async getFilesystemAttachment(
+    request: operations.GetFilesystemAttachmentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetFilesystemAttachmentResponse> {
+    return unwrapAsync(filesystemStorageGetFilesystemAttachment(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Attach filesystem to server
+   *
+   * @remarks
+   * Attaches a running server to the private storage network the filesystem is served on, so it can mount the filesystem. The attach runs asynchronously and is idempotent.
+   */
+  async attachFilesystem(
+    request: operations.AttachFilesystemRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(filesystemStorageAttachFilesystem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Detach filesystem from server
+   *
+   * @remarks
+   * Detaches a server from the storage network the filesystem is served on, removing its storage IP and VLAN. The network stays while a volume is still mapped to the server, since volumes use the same network. The detach runs asynchronously: poll GET .../attach for its status.
+   */
+  async detachFilesystem(
+    request: operations.DetachFilesystemRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(filesystemStorageDetachFilesystem(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/lks.ts

@@ -9,9 +9,11 @@ import { lksDeleteLKSNodePool } from "../funcs/lksDeleteLKSNodePool.js";
 import { lksGetLKSCluster } from "../funcs/lksGetLKSCluster.js";
 import { lksGetLKSClusterKubeconfig } from "../funcs/lksGetLKSClusterKubeconfig.js";
 import { lksGetLKSNodePool } from "../funcs/lksGetLKSNodePool.js";
+import { lksListLKSAllocatableServers } from "../funcs/lksListLKSAllocatableServers.js";
 import { lksListLKSAvailableVersions } from "../funcs/lksListLKSAvailableVersions.js";
 import { lksListLKSClusters } from "../funcs/lksListLKSClusters.js";
 import { lksListLKSNodePools } from "../funcs/lksListLKSNodePools.js";
+import { lksListLKSNodes } from "../funcs/lksListLKSNodes.js";
 import { lksListLKSSites } from "../funcs/lksListLKSSites.js";
 import { lksUpdateLKSCluster } from "../funcs/lksUpdateLKSCluster.js";
 import { lksUpdateLKSNodePool } from "../funcs/lksUpdateLKSNodePool.js";
@@ -154,9 +156,12 @@ export class Lks extends ClientSDK {
    * Create a node pool
    *
    * @remarks
-   * Adds a node pool to an LKS cluster. The platform provisions `count` servers of `plan` from stock, so both fields are required.
+   * Adds a node pool to an LKS cluster. `mode` decides where the pool's nodes come from:
    *
-   * `kubernetes_version` defaults to the control-plane patch and may never be newer than it. `max_pods_per_node` is set once, here — it cannot be changed later.
+   * - `on_demand` (default): the platform provisions `count` servers of `plan` from stock, so both fields are required.
+   * - `allocated`: the pool is built from `server_ids`, bare metal servers already in the cluster project. Each server is reinstalled with the LKS node image, which erases its disks. `plan` and `count` are rejected: the pool uses the plan the servers share, and `count` is the number of servers. Each server that fails an eligibility check is reported as its own 422 error, pointing at its index in `server_ids` and listing every reason in `meta.reasons`. `GET /lks/allocatable_servers` shows which servers can join. Allocated node pools are available only in on-demand projects: a reserved project is refused with 422 `RESERVED_PROJECT_NOT_SUPPORTED`.
+   *
+   * `kubernetes_version` defaults to the control-plane patch and may never be newer than it. `max_pods_per_node` and `mode` are set once, here — they cannot be changed later.
    */
   async createLksNodePool(
     request: operations.CreateLksNodePoolRequest,
@@ -207,11 +212,13 @@ export class Lks extends ClientSDK {
    * Update a node pool
    *
    * @remarks
-   * Scales, renames, upgrades or re-labels a node pool. At least one attribute must be provided.
+   * Scales, renames, upgrades, re-labels or changes the servers of a node pool. At least one attribute must be provided.
    *
    * `labels` and `taints` are declarative replacements, not merges: omit the field to leave it untouched, send the whole map/list to replace it, or send `{}` / `[]` to clear it.
    *
-   * A newer `kubernetes_version` rolls a node-recreating upgrade; it must not be lower than the pool's current patch nor newer than the control-plane patch. `max_pods_per_node` is immutable — a PATCH that carries it is rejected with 422 even if the value is unchanged.
+   * A newer `kubernetes_version` rolls a node-recreating upgrade; it must not be lower than the pool's current patch nor newer than the control-plane patch. `max_pods_per_node` and `mode` are immutable — a PATCH that carries either is rejected with 422 even if the value is unchanged.
+   *
+   * For an allocated node pool, `server_ids` replaces `count`: send the whole set of servers the pool should have. Added servers are checked as on create and reinstalled to join; removed servers are drained and reinstalled with a clean OS, with no data, keys or user data restored. A server set change cannot be combined with a `kubernetes_version` change.
    *
    * The node pool must be idle: one that is provisioning, updating, scaling, upgrading, paused or deleting rejects the request with 409.
    */
@@ -226,6 +233,23 @@ export class Lks extends ClientSDK {
     ));
   }
 
+  /**
+   * List nodes
+   *
+   * @remarks
+   * Lists the nodes of a node pool, with the status of each node and of the server it runs on. Each node's `id` is a stable node ID (format: `lksno_<hash>`); `name` is its Kubernetes node name, as shown by `kubectl get nodes`. The response is not paginated; `meta.total` is the number of nodes returned.
+   */
+  async listLksNodes(
+    request: operations.ListLksNodesRequest,
+    options?: RequestOptions,
+  ): Promise<models.LksNodes> {
+    return unwrapAsync(lksListLKSNodes(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * List available Kubernetes versions
    *
@@ -255,4 +279,23 @@ export class Lks extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * List servers that can join an allocated node pool
+   *
+   * @remarks
+   * Lists a project's servers at a site, with whether each one can join an allocated node pool right now. Pass the `id` of an allocatable server in `server_ids` when creating or updating an allocated node pool.
+   *
+   * When `allocatable` is false, `reasons` lists why, using the same codes that node pool create and update return per server. `node_pool_id` and `cluster_id` identify the pool a server already belongs to.
+   */
+  async listLksAllocatableServers(
+    request: operations.ListLksAllocatableServersRequest,
+    options?: RequestOptions,
+  ): Promise<models.LksAllocatableServers> {
+    return unwrapAsync(lksListLKSAllocatableServers(
+      this,
+      request,
+      options,
+    ));
+  }
 }