latitudesh-typescript-sdk 0.3.9 → 0.4.1

package/src/models/operations/updateserverdeployconfig.ts

@@ -51,6 +51,39 @@ export type UpdateServerDeployConfigRaid2 = ClosedEnum<
   typeof UpdateServerDeployConfigRaid2
 >;
 
+export const UpdateServerDeployConfigRole2 = {
+  Os: "os",
+  Storage: "storage",
+  Raw: "raw",
+} as const;
+export type UpdateServerDeployConfigRole2 = ClosedEnum<
+  typeof UpdateServerDeployConfigRole2
+>;
+
+export const UpdateServerDeployConfigRaidLevel2 = {
+  Raid0: "raid-0",
+  Raid1: "raid-1",
+} as const;
+export type UpdateServerDeployConfigRaidLevel2 = ClosedEnum<
+  typeof UpdateServerDeployConfigRaidLevel2
+>;
+
+export const UpdateServerDeployConfigFilesystem2 = {
+  Ext4: "ext4",
+  Xfs: "xfs",
+} as const;
+export type UpdateServerDeployConfigFilesystem2 = ClosedEnum<
+  typeof UpdateServerDeployConfigFilesystem2
+>;
+
+export type UpdateServerDeployConfigDiskLayout2 = {
+  count: number;
+  role: UpdateServerDeployConfigRole2;
+  raidLevel?: UpdateServerDeployConfigRaidLevel2 | null | undefined;
+  filesystem?: UpdateServerDeployConfigFilesystem2 | null | undefined;
+  mountPoint?: string | null | undefined;
+};
+
 export type UpdateServerDeployConfigPartition2 = {
   sizeInGb?: number | undefined;
   path?: string | undefined;
@@ -64,6 +97,7 @@ export type UpdateServerDeployConfigAttributes2 = {
    * RAID mode for the server. Set to 'raid-0' for RAID 0, 'raid-1' for RAID 1, or omit/null for no RAID configuration
    */
   raid?: UpdateServerDeployConfigRaid2 | null | undefined;
+  diskLayout?: Array<UpdateServerDeployConfigDiskLayout2> | null | undefined;
   /**
    * User data to configure the server
    */
@@ -116,6 +150,101 @@ export const UpdateServerDeployConfigRaid2$outboundSchema: z.ZodNativeEnum<
   typeof UpdateServerDeployConfigRaid2
 > = UpdateServerDeployConfigRaid2$inboundSchema;
 
+/** @internal */
+export const UpdateServerDeployConfigRole2$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateServerDeployConfigRole2
+> = z.nativeEnum(UpdateServerDeployConfigRole2);
+/** @internal */
+export const UpdateServerDeployConfigRole2$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateServerDeployConfigRole2
+> = UpdateServerDeployConfigRole2$inboundSchema;
+
+/** @internal */
+export const UpdateServerDeployConfigRaidLevel2$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateServerDeployConfigRaidLevel2
+> = z.nativeEnum(UpdateServerDeployConfigRaidLevel2);
+/** @internal */
+export const UpdateServerDeployConfigRaidLevel2$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateServerDeployConfigRaidLevel2
+> = UpdateServerDeployConfigRaidLevel2$inboundSchema;
+
+/** @internal */
+export const UpdateServerDeployConfigFilesystem2$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateServerDeployConfigFilesystem2
+> = z.nativeEnum(UpdateServerDeployConfigFilesystem2);
+/** @internal */
+export const UpdateServerDeployConfigFilesystem2$outboundSchema:
+  z.ZodNativeEnum<typeof UpdateServerDeployConfigFilesystem2> =
+    UpdateServerDeployConfigFilesystem2$inboundSchema;
+
+/** @internal */
+export const UpdateServerDeployConfigDiskLayout2$inboundSchema: z.ZodType<
+  UpdateServerDeployConfigDiskLayout2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int(),
+  role: UpdateServerDeployConfigRole2$inboundSchema,
+  raid_level: z.nullable(UpdateServerDeployConfigRaidLevel2$inboundSchema)
+    .optional(),
+  filesystem: z.nullable(UpdateServerDeployConfigFilesystem2$inboundSchema)
+    .optional(),
+  mount_point: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "raid_level": "raidLevel",
+    "mount_point": "mountPoint",
+  });
+});
+/** @internal */
+export type UpdateServerDeployConfigDiskLayout2$Outbound = {
+  count: number;
+  role: string;
+  raid_level?: string | null | undefined;
+  filesystem?: string | null | undefined;
+  mount_point?: string | null | undefined;
+};
+
+/** @internal */
+export const UpdateServerDeployConfigDiskLayout2$outboundSchema: z.ZodType<
+  UpdateServerDeployConfigDiskLayout2$Outbound,
+  z.ZodTypeDef,
+  UpdateServerDeployConfigDiskLayout2
+> = z.object({
+  count: z.number().int(),
+  role: UpdateServerDeployConfigRole2$outboundSchema,
+  raidLevel: z.nullable(UpdateServerDeployConfigRaidLevel2$outboundSchema)
+    .optional(),
+  filesystem: z.nullable(UpdateServerDeployConfigFilesystem2$outboundSchema)
+    .optional(),
+  mountPoint: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    raidLevel: "raid_level",
+    mountPoint: "mount_point",
+  });
+});
+
+export function updateServerDeployConfigDiskLayout2ToJSON(
+  updateServerDeployConfigDiskLayout2: UpdateServerDeployConfigDiskLayout2,
+): string {
+  return JSON.stringify(
+    UpdateServerDeployConfigDiskLayout2$outboundSchema.parse(
+      updateServerDeployConfigDiskLayout2,
+    ),
+  );
+}
+export function updateServerDeployConfigDiskLayout2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateServerDeployConfigDiskLayout2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateServerDeployConfigDiskLayout2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateServerDeployConfigDiskLayout2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateServerDeployConfigPartition2$inboundSchema: z.ZodType<
   UpdateServerDeployConfigPartition2,
@@ -185,6 +314,9 @@ export const UpdateServerDeployConfigAttributes2$inboundSchema: z.ZodType<
     UpdateServerDeployConfigOperatingSystem2$inboundSchema,
   ).optional(),
   raid: z.nullable(UpdateServerDeployConfigRaid2$inboundSchema).optional(),
+  disk_layout: z.nullable(
+    z.array(z.lazy(() => UpdateServerDeployConfigDiskLayout2$inboundSchema)),
+  ).optional(),
   user_data: z.nullable(z.string()).optional(),
   ssh_keys: z.nullable(z.array(z.string())).optional(),
   partitions: z.nullable(
@@ -194,6 +326,7 @@ export const UpdateServerDeployConfigAttributes2$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "operating_system": "operatingSystem",
+    "disk_layout": "diskLayout",
     "user_data": "userData",
     "ssh_keys": "sshKeys",
     "ipxe_url": "ipxeUrl",
@@ -204,6 +337,10 @@ export type UpdateServerDeployConfigAttributes2$Outbound = {
   hostname?: string | null | undefined;
   operating_system?: string | null | undefined;
   raid?: string | null | undefined;
+  disk_layout?:
+    | Array<UpdateServerDeployConfigDiskLayout2$Outbound>
+    | null
+    | undefined;
   user_data?: string | null | undefined;
   ssh_keys?: Array<string> | null | undefined;
   partitions?:
@@ -224,6 +361,9 @@ export const UpdateServerDeployConfigAttributes2$outboundSchema: z.ZodType<
     UpdateServerDeployConfigOperatingSystem2$outboundSchema,
   ).optional(),
   raid: z.nullable(UpdateServerDeployConfigRaid2$outboundSchema).optional(),
+  diskLayout: z.nullable(
+    z.array(z.lazy(() => UpdateServerDeployConfigDiskLayout2$outboundSchema)),
+  ).optional(),
   userData: z.nullable(z.string()).optional(),
   sshKeys: z.nullable(z.array(z.string())).optional(),
   partitions: z.nullable(
@@ -233,6 +373,7 @@ export const UpdateServerDeployConfigAttributes2$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     operatingSystem: "operating_system",
+    diskLayout: "disk_layout",
     userData: "user_data",
     sshKeys: "ssh_keys",
     ipxeUrl: "ipxe_url",

package/src/models/serverdata.ts

@@ -158,7 +158,7 @@ export type ServerDataRole = ClosedEnum<typeof ServerDataRole>;
 export type Interface = {
   role?: ServerDataRole | undefined;
   name?: string | undefined;
-  macAddress?: string | undefined;
+  macAddress?: string | null | undefined;
   description?: string | undefined;
 };
 
@@ -484,7 +484,7 @@ export const Interface$inboundSchema: z.ZodType<
 > = z.object({
   role: ServerDataRole$inboundSchema.optional(),
   name: z.string().optional(),
-  mac_address: z.string().optional(),
+  mac_address: z.nullable(z.string()).optional(),
   description: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -495,7 +495,7 @@ export const Interface$inboundSchema: z.ZodType<
 export type Interface$Outbound = {
   role?: string | undefined;
   name?: string | undefined;
-  mac_address?: string | undefined;
+  mac_address?: string | null | undefined;
   description?: string | undefined;
 };
 
@@ -507,7 +507,7 @@ export const Interface$outboundSchema: z.ZodType<
 > = z.object({
   role: ServerDataRole$outboundSchema.optional(),
   name: z.string().optional(),
-  macAddress: z.string().optional(),
+  macAddress: z.nullable(z.string()).optional(),
   description: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/virtualmachineattributes.ts

@@ -102,7 +102,13 @@ export type VirtualMachineAttributesOperatingSystem = {
   distro?: VirtualMachineAttributesDistro | undefined;
 };
 
+/**
+ * SSH credentials for connecting to the virtual machine. Only available when the VM is running.
+ */
 export type VirtualMachineAttributesCredentials = {
+  /**
+   * The SSH username for the VM, determined by the operating system (e.g., ubuntu, centos, ec2-user). Defaults to ubuntu if not specified by the OS.
+   */
   username?: string | undefined;
   host?: string | undefined;
   password?: string | undefined;
@@ -131,6 +137,9 @@ export type VirtualMachineAttributesAttributes = {
    * The operating system installed on the virtual machine
    */
   operatingSystem?: VirtualMachineAttributesOperatingSystem | null | undefined;
+  /**
+   * SSH credentials for connecting to the virtual machine. Only available when the VM is running.
+   */
   credentials?: VirtualMachineAttributesCredentials | null | undefined;
   plan?: VirtualMachineAttributesPlan | undefined;
   specs?: VirtualMachineAttributesSpecs | undefined;

package/src/sdk/blockstorage.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { blockStorageDeleteStorageVolumes } from "../funcs/blockStorageDeleteStorageVolumes.js";
+import { blockStorageGetStorageVolume } from "../funcs/blockStorageGetStorageVolume.js";
+import { blockStorageGetStorageVolumes } from "../funcs/blockStorageGetStorageVolumes.js";
+import { blockStoragePostStorageVolumes } from "../funcs/blockStoragePostStorageVolumes.js";
+import { blockStoragePostStorageVolumesMount } from "../funcs/blockStoragePostStorageVolumesMount.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class BlockStorage extends ClientSDK {
+  /**
+   * List volumes
+   *
+   * @remarks
+   * Lists all the volumes from a team.
+   */
+  async getStorageVolumes(
+    request?: operations.GetStorageVolumesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetStorageVolumesResponse> {
+    return unwrapAsync(blockStorageGetStorageVolumes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create volume
+   *
+   * @remarks
+   * Allows you to add persistent storage to a project. These volumes can be used to store data across your servers.
+   */
+  async postStorageVolumes(
+    request: operations.PostStorageVolumesRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostStorageVolumesResponse> {
+    return unwrapAsync(blockStoragePostStorageVolumes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve volume
+   *
+   * @remarks
+   * Shows details of a specific volume storage.
+   */
+  async getStorageVolume(
+    request: operations.GetStorageVolumeRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetStorageVolumeResponse> {
+    return unwrapAsync(blockStorageGetStorageVolume(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete volume
+   *
+   * @remarks
+   * Allows you to remove persistent storage from a project.
+   */
+  async deleteStorageVolumes(
+    request: operations.DeleteStorageVolumesRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(blockStorageDeleteStorageVolumes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Mount volume
+   *
+   * @remarks
+   * Mounts volume storage by adding the client to an allowed list
+   */
+  async postStorageVolumesMount(
+    request: operations.PostStorageVolumesMountRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(blockStoragePostStorageVolumesMount(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/elasticips.ts

@@ -19,8 +19,6 @@ export class ElasticIps extends ClientSDK {
    *
    * @remarks
    * List all Elastic IPs for the authenticated team. Elastic IPs are static public IP addresses that can be assigned to servers and moved between servers within the same project.
-   *
-   * **Note:** This feature requires the `elastic_ips` feature flag to be enabled for your team. When the flag is disabled, the endpoint returns an empty list.
    */
   async listElasticIps(
     request?: operations.ListElasticIpsRequest | undefined,
@@ -39,9 +37,7 @@ export class ElasticIps extends ClientSDK {
    * Create an Elastic IP
    *
    * @remarks
-   * Creates a new Elastic IP and assigns it to the specified server. The IP is provisioned asynchronously—the response will show status `configuring` and the `id` will be `null` until provisioning completes.
-   *
-   * **Note:** This feature requires the `elastic_ips` feature flag to be enabled for your team. Currently only IPv4 /32 addresses in routed mode are supported.
+   * Creates a new Elastic IP and assigns it to the specified server. The IP is provisioned asynchronously—the response will show status `configuring` and the `id` will be `null` until provisioning completes. Currently only IPv4 /32 addresses in routed mode are supported.
    */
   async createElasticIp(
     request: models.CreateElasticIp,
@@ -59,8 +55,6 @@ export class ElasticIps extends ClientSDK {
    *
    * @remarks
    * Returns a single Elastic IP by its ID.
-   *
-   * **Note:** This feature requires the `elastic_ips` feature flag to be enabled for your team.
    */
   async getElasticIp(
     request: operations.GetElasticIpRequest,
@@ -77,9 +71,7 @@ export class ElasticIps extends ClientSDK {
    * Release an Elastic IP
    *
    * @remarks
-   * Releases an Elastic IP, returning it to the available pool. The IP will transition to `releasing` status before being fully removed.
-   *
-   * **Note:** This feature requires the `elastic_ips` feature flag to be enabled for your team. Only Elastic IPs with status `active` or `error` can be released.
+   * Releases an Elastic IP, returning it to the available pool. The IP will transition to `releasing` status before being fully removed. Only Elastic IPs with status `active` or `error` can be released.
    */
   async deleteElasticIp(
     request: operations.DeleteElasticIpRequest,
@@ -96,9 +88,7 @@ export class ElasticIps extends ClientSDK {
    * Move an Elastic IP
    *
    * @remarks
-   * Moves an Elastic IP to a different server within the same project. The reassignment is performed asynchronously.
-   *
-   * **Note:** This feature requires the `elastic_ips` feature flag to be enabled for your team. The Elastic IP must be in `active` status and the target server must belong to the same project.
+   * Moves an Elastic IP to a different server within the same project and site. The reassignment is performed asynchronously. The Elastic IP must be in `active` status, the target server must belong to the same project, and the target server must be in the same site as the currently assigned server.
    */
   async updateElasticIp(
     request: operations.UpdateElasticIpRequest,

package/src/sdk/filesystemstorage.ts

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { filesystemStorageCreateFilesystem } from "../funcs/filesystemStorageCreateFilesystem.js";
+import { filesystemStorageDeleteFilesystem } from "../funcs/filesystemStorageDeleteFilesystem.js";
+import { filesystemStorageListFilesystems } from "../funcs/filesystemStorageListFilesystems.js";
+import { filesystemStorageUpdateFilesystem } from "../funcs/filesystemStorageUpdateFilesystem.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class FilesystemStorage extends ClientSDK {
+  /**
+   * Create filesystem
+   *
+   * @remarks
+   * 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,
+    options?: RequestOptions,
+  ): Promise<operations.PostStorageFilesystemsResponse> {
+    return unwrapAsync(filesystemStorageCreateFilesystem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List filesystems
+   *
+   * @remarks
+   * Lists all the filesystems from a team.
+   */
+  async listFilesystems(
+    request?: operations.GetStorageFilesystemsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(filesystemStorageListFilesystems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete filesystem
+   *
+   * @remarks
+   * Allows you to remove persistent storage from a project.
+   */
+  async deleteFilesystem(
+    request: operations.DeleteStorageFilesystemsRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(filesystemStorageDeleteFilesystem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update filesystem
+   *
+   * @remarks
+   * Allow you to upgrade the size of a filesystem.
+   */
+  async updateFilesystem(
+    request: operations.PatchStorageFilesystemsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchStorageFilesystemsResponse> {
+    return unwrapAsync(filesystemStorageUpdateFilesystem(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/kubernetesclusters.ts

@@ -38,6 +38,8 @@ export class KubernetesClusters extends ClientSDK {
    * @remarks
    * Creates a new managed Kubernetes cluster. Maximum of 1 cluster per project.
    *
+   * **Note:** Only users with the `owner`, `administrator`, or `collaborator` role can create clusters. Users with the `billing` role cannot perform this action.
+   *
    * Cluster names must follow Kubernetes naming rules: lowercase alphanumeric characters or hyphens, must start and end with an alphanumeric character, and be at most 63 characters long.
    */
   async createKubernetesCluster(
@@ -94,6 +96,8 @@ export class KubernetesClusters extends ClientSDK {
    *
    * @remarks
    * Deletes a Kubernetes cluster. This action is irreversible and will destroy all cluster resources.
+   *
+   * **Note:** Only users with the `owner`, `administrator`, or `collaborator` role can delete clusters. Users with the `billing` role cannot perform this action.
    */
   async deleteKubernetesCluster(
     request: operations.DeleteKubernetesClusterRequest,
@@ -149,6 +153,8 @@ export class KubernetesClusters extends ClientSDK {
    *
    * @remarks
    * Retrieves the kubeconfig file for a Kubernetes cluster. The kubeconfig is only available once the cluster is fully provisioned.
+   *
+   * **Note:** Only users with the `owner`, `administrator`, or `collaborator` role can access cluster credentials. Users with the `billing` role cannot perform this action.
    */
   async getKubernetesClusterKubeconfig(
     request: operations.GetKubernetesClusterKubeconfigRequest,

package/src/sdk/objectstorage.ts

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { objectStorageDeleteStorageBuckets } from "../funcs/objectStorageDeleteStorageBuckets.js";
+import { objectStorageGetStorageBucket } from "../funcs/objectStorageGetStorageBucket.js";
+import { objectStorageGetStorageBuckets } from "../funcs/objectStorageGetStorageBuckets.js";
+import { objectStoragePostStorageBuckets } from "../funcs/objectStoragePostStorageBuckets.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class ObjectStorage extends ClientSDK {
+  /**
+   * List object storages
+   *
+   * @remarks
+   * Lists all object storages from a team.
+   */
+  async getStorageBuckets(
+    request?: operations.GetStorageBucketsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ObjectStorages> {
+    return unwrapAsync(objectStorageGetStorageBuckets(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create object storage
+   *
+   * @remarks
+   * Creates a new object storage bucket for a project.
+   */
+  async postStorageBuckets(
+    request: operations.PostStorageBucketsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostStorageBucketsResponse> {
+    return unwrapAsync(objectStoragePostStorageBuckets(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve object storage
+   *
+   * @remarks
+   * Shows details of a specific object storage.
+   */
+  async getStorageBucket(
+    request: operations.GetStorageBucketRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetStorageBucketResponse> {
+    return unwrapAsync(objectStorageGetStorageBucket(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete object storage
+   *
+   * @remarks
+   * Allows you to remove an object storage from a project.
+   */
+  async deleteStorageBuckets(
+    request: operations.DeleteStorageBucketsRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(objectStorageDeleteStorageBuckets(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/projects.ts

@@ -65,6 +65,9 @@ export class Projects extends ClientSDK {
 
   /**
    * Delete project
+   *
+   * @remarks
+   * Deletes a project and releases associated resources. Any Elastic IPs assigned to the project are automatically released and returned to the available pool.
    */
   async delete(
     request: operations.DeleteProjectRequest,

package/src/sdk/sdk.ts

@@ -5,11 +5,14 @@
 import { ClientSDK } from "../lib/sdks.js";
 import { ApiKeys } from "./apikeys.js";
 import { Billing } from "./billing.js";
+import { BlockStorage } from "./blockstorage.js";
 import { ElasticIps } from "./elasticips.js";
 import { Events } from "./events.js";
+import { FilesystemStorage } from "./filesystemstorage.js";
 import { Firewalls } from "./firewalls.js";
 import { IpAddresses } from "./ipaddresses.js";
 import { KubernetesClusters } from "./kubernetesclusters.js";
+import { ObjectStorage } from "./objectstorage.js";
 import { OperatingSystems } from "./operatingsystems.js";
 import { Plans } from "./plans.js";
 import { PrivateNetworks } from "./privatenetworks.js";
@@ -18,7 +21,6 @@ import { Regions } from "./regions.js";
 import { Roles } from "./roles.js";
 import { Servers } from "./servers.js";
 import { SSHKeys } from "./sshkeys.js";
-import { Storage } from "./storage.js";
 import { Tags } from "./tags.js";
 import { TeamMembers } from "./teammembers.js";
 import { Teams } from "./teams.js";
@@ -115,9 +117,19 @@ export class Latitudesh extends ClientSDK {
     return (this._servers ??= new Servers(this._options));
   }
 
-  private _storage?: Storage;
-  get storage(): Storage {
-    return (this._storage ??= new Storage(this._options));
+  private _filesystemStorage?: FilesystemStorage;
+  get filesystemStorage(): FilesystemStorage {
+    return (this._filesystemStorage ??= new FilesystemStorage(this._options));
+  }
+
+  private _blockStorage?: BlockStorage;
+  get blockStorage(): BlockStorage {
+    return (this._blockStorage ??= new BlockStorage(this._options));
+  }
+
+  private _objectStorage?: ObjectStorage;
+  get objectStorage(): ObjectStorage {
+    return (this._objectStorage ??= new ObjectStorage(this._options));
   }
 
   private _tags?: Tags;

package/src/types/async.ts

@@ -21,16 +21,17 @@ export type APICall =
 
 export class APIPromise<T> implements Promise<T> {
   readonly #promise: Promise<[T, APICall]>;
-  readonly #unwrapped: Promise<T>;
+  #unwrapped: Promise<T> | null;
 
   readonly [Symbol.toStringTag] = "APIPromise";
 
   constructor(p: [T, APICall] | Promise<[T, APICall]>) {
     this.#promise = p instanceof Promise ? p : Promise.resolve(p);
-    this.#unwrapped =
-      p instanceof Promise
-        ? this.#promise.then(([value]) => value)
-        : Promise.resolve(p[0]);
+    this.#unwrapped = p instanceof Promise ? null : Promise.resolve(p[0]);
+  }
+
+  #getUnwrapped(): Promise<T> {
+    return (this.#unwrapped ??= this.#promise.then(([value]) => value));
   }
 
   then<TResult1 = T, TResult2 = never>(
@@ -55,11 +56,11 @@ export class APIPromise<T> implements Promise<T> {
       | null
       | undefined,
   ): Promise<T | TResult> {
-    return this.#unwrapped.catch(onrejected);
+    return this.#getUnwrapped().catch(onrejected);
   }
 
   finally(onfinally?: (() => void) | null | undefined): Promise<T> {
-    return this.#unwrapped.finally(onfinally);
+    return this.#getUnwrapped().finally(onfinally);
   }
 
   $inspect(): Promise<[T, APICall]> {