latitudesh-typescript-sdk 0.3.3 → 0.3.5

package/src/models/virtualmachineattributes.ts

@@ -34,11 +34,74 @@ export const VirtualMachineAttributesStatus = {
   Starting: "Starting",
   Scheduling: "Scheduling",
   Scheduled: "Scheduled",
+  Destroying: "Destroying",
 } as const;
 export type VirtualMachineAttributesStatus = ClosedEnum<
   typeof VirtualMachineAttributesStatus
 >;
 
+/**
+ * Features supported by this operating system
+ */
+export type VirtualMachineAttributesFeatures = {
+  /**
+   * Whether RAID is supported
+   */
+  raid?: boolean | undefined;
+  /**
+   * Whether SSH keys are supported
+   */
+  sshKeys?: boolean | undefined;
+  /**
+   * Whether user data is supported
+   */
+  userData?: boolean | undefined;
+};
+
+/**
+ * Distribution information
+ */
+export type VirtualMachineAttributesDistro = {
+  /**
+   * The name of the Linux distribution
+   */
+  name?: string | undefined;
+  /**
+   * The slug of the Linux distribution
+   */
+  slug?: string | undefined;
+  /**
+   * The distribution series code name
+   */
+  series?: string | undefined;
+};
+
+/**
+ * The operating system installed on the virtual machine
+ */
+export type VirtualMachineAttributesOperatingSystem = {
+  /**
+   * The full name of the operating system
+   */
+  name?: string | undefined;
+  /**
+   * The unique slug identifier for the operating system
+   */
+  slug?: string | undefined;
+  /**
+   * The version of the operating system
+   */
+  version?: string | undefined;
+  /**
+   * Features supported by this operating system
+   */
+  features?: VirtualMachineAttributesFeatures | undefined;
+  /**
+   * Distribution information
+   */
+  distro?: VirtualMachineAttributesDistro | undefined;
+};
+
 export type VirtualMachineAttributesCredentials = {
   username?: string | undefined;
   host?: string | undefined;
@@ -64,7 +127,10 @@ export type VirtualMachineAttributesAttributes = {
   createdAt?: string | undefined;
   status?: VirtualMachineAttributesStatus | undefined;
   primaryIpv4?: string | null | undefined;
-  operatingSystem?: string | null | undefined;
+  /**
+   * The operating system installed on the virtual machine
+   */
+  operatingSystem?: VirtualMachineAttributesOperatingSystem | null | undefined;
   credentials?: VirtualMachineAttributesCredentials | null | undefined;
   plan?: VirtualMachineAttributesPlan | undefined;
   specs?: VirtualMachineAttributesSpecs | undefined;
@@ -96,6 +162,173 @@ export const VirtualMachineAttributesStatus$outboundSchema: z.ZodNativeEnum<
   typeof VirtualMachineAttributesStatus
 > = VirtualMachineAttributesStatus$inboundSchema;
 
+/** @internal */
+export const VirtualMachineAttributesFeatures$inboundSchema: z.ZodType<
+  VirtualMachineAttributesFeatures,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  raid: z.boolean().optional(),
+  ssh_keys: z.boolean().optional(),
+  user_data: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ssh_keys": "sshKeys",
+    "user_data": "userData",
+  });
+});
+/** @internal */
+export type VirtualMachineAttributesFeatures$Outbound = {
+  raid?: boolean | undefined;
+  ssh_keys?: boolean | undefined;
+  user_data?: boolean | undefined;
+};
+
+/** @internal */
+export const VirtualMachineAttributesFeatures$outboundSchema: z.ZodType<
+  VirtualMachineAttributesFeatures$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineAttributesFeatures
+> = z.object({
+  raid: z.boolean().optional(),
+  sshKeys: z.boolean().optional(),
+  userData: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    sshKeys: "ssh_keys",
+    userData: "user_data",
+  });
+});
+
+export function virtualMachineAttributesFeaturesToJSON(
+  virtualMachineAttributesFeatures: VirtualMachineAttributesFeatures,
+): string {
+  return JSON.stringify(
+    VirtualMachineAttributesFeatures$outboundSchema.parse(
+      virtualMachineAttributesFeatures,
+    ),
+  );
+}
+export function virtualMachineAttributesFeaturesFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineAttributesFeatures, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineAttributesFeatures$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineAttributesFeatures' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineAttributesDistro$inboundSchema: z.ZodType<
+  VirtualMachineAttributesDistro,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  series: z.string().optional(),
+});
+/** @internal */
+export type VirtualMachineAttributesDistro$Outbound = {
+  name?: string | undefined;
+  slug?: string | undefined;
+  series?: string | undefined;
+};
+
+/** @internal */
+export const VirtualMachineAttributesDistro$outboundSchema: z.ZodType<
+  VirtualMachineAttributesDistro$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineAttributesDistro
+> = z.object({
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  series: z.string().optional(),
+});
+
+export function virtualMachineAttributesDistroToJSON(
+  virtualMachineAttributesDistro: VirtualMachineAttributesDistro,
+): string {
+  return JSON.stringify(
+    VirtualMachineAttributesDistro$outboundSchema.parse(
+      virtualMachineAttributesDistro,
+    ),
+  );
+}
+export function virtualMachineAttributesDistroFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachineAttributesDistro, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachineAttributesDistro$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachineAttributesDistro' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachineAttributesOperatingSystem$inboundSchema: z.ZodType<
+  VirtualMachineAttributesOperatingSystem,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  version: z.string().optional(),
+  features: z.lazy(() => VirtualMachineAttributesFeatures$inboundSchema)
+    .optional(),
+  distro: z.lazy(() => VirtualMachineAttributesDistro$inboundSchema).optional(),
+});
+/** @internal */
+export type VirtualMachineAttributesOperatingSystem$Outbound = {
+  name?: string | undefined;
+  slug?: string | undefined;
+  version?: string | undefined;
+  features?: VirtualMachineAttributesFeatures$Outbound | undefined;
+  distro?: VirtualMachineAttributesDistro$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachineAttributesOperatingSystem$outboundSchema: z.ZodType<
+  VirtualMachineAttributesOperatingSystem$Outbound,
+  z.ZodTypeDef,
+  VirtualMachineAttributesOperatingSystem
+> = z.object({
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  version: z.string().optional(),
+  features: z.lazy(() => VirtualMachineAttributesFeatures$outboundSchema)
+    .optional(),
+  distro: z.lazy(() => VirtualMachineAttributesDistro$outboundSchema)
+    .optional(),
+});
+
+export function virtualMachineAttributesOperatingSystemToJSON(
+  virtualMachineAttributesOperatingSystem:
+    VirtualMachineAttributesOperatingSystem,
+): string {
+  return JSON.stringify(
+    VirtualMachineAttributesOperatingSystem$outboundSchema.parse(
+      virtualMachineAttributesOperatingSystem,
+    ),
+  );
+}
+export function virtualMachineAttributesOperatingSystemFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  VirtualMachineAttributesOperatingSystem,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      VirtualMachineAttributesOperatingSystem$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'VirtualMachineAttributesOperatingSystem' from JSON`,
+  );
+}
+
 /** @internal */
 export const VirtualMachineAttributesCredentials$inboundSchema: z.ZodType<
   VirtualMachineAttributesCredentials,
@@ -262,7 +495,9 @@ export const VirtualMachineAttributesAttributes$inboundSchema: z.ZodType<
   created_at: z.string().optional(),
   status: VirtualMachineAttributesStatus$inboundSchema.optional(),
   primary_ipv4: z.nullable(z.string()).optional(),
-  operating_system: z.nullable(z.string()).optional(),
+  operating_system: z.nullable(
+    z.lazy(() => VirtualMachineAttributesOperatingSystem$inboundSchema),
+  ).optional(),
   credentials: z.nullable(
     z.lazy(() => VirtualMachineAttributesCredentials$inboundSchema),
   ).optional(),
@@ -283,7 +518,10 @@ export type VirtualMachineAttributesAttributes$Outbound = {
   created_at?: string | undefined;
   status?: string | undefined;
   primary_ipv4?: string | null | undefined;
-  operating_system?: string | null | undefined;
+  operating_system?:
+    | VirtualMachineAttributesOperatingSystem$Outbound
+    | null
+    | undefined;
   credentials?: VirtualMachineAttributesCredentials$Outbound | null | undefined;
   plan?: VirtualMachineAttributesPlan$Outbound | undefined;
   specs?: VirtualMachineAttributesSpecs$Outbound | undefined;
@@ -301,7 +539,9 @@ export const VirtualMachineAttributesAttributes$outboundSchema: z.ZodType<
   createdAt: z.string().optional(),
   status: VirtualMachineAttributesStatus$outboundSchema.optional(),
   primaryIpv4: z.nullable(z.string()).optional(),
-  operatingSystem: z.nullable(z.string()).optional(),
+  operatingSystem: z.nullable(
+    z.lazy(() => VirtualMachineAttributesOperatingSystem$outboundSchema),
+  ).optional(),
   credentials: z.nullable(
     z.lazy(() => VirtualMachineAttributesCredentials$outboundSchema),
   ).optional(),

package/src/models/virtualmachinepayload.ts

@@ -25,7 +25,7 @@ export type VirtualMachinePayloadAttributes = {
   sshKeys?: Array<string> | null | undefined;
   project?: string | undefined;
   /**
-   * The operating system slug for the Virtual Machine. Defaults to ubuntu_24_04_x64_lts if not specified.
+   * The operating system slug for the Virtual Machine. If not specified, defaults to ubuntu-24-04 for CPU plans or ubuntu24_ml_in_a_box for GPU plans.
    */
   operatingSystem?: string | null | undefined;
 };

package/src/models/virtualmachineplans.ts

@@ -193,6 +193,10 @@ export type VirtualMachinePlansAttributes = {
    * The stock level of the plan
    */
   stockLevel?: VirtualMachinePlansStockLevel | undefined;
+  /**
+   * List of operating system slugs that are compatible with this plan
+   */
+  availableOperatingSystems?: Array<string> | undefined;
 };
 
 export type VirtualMachinePlansData = {
@@ -721,9 +725,11 @@ export const VirtualMachinePlansAttributes$inboundSchema: z.ZodType<
   regions: z.array(z.lazy(() => VirtualMachinePlansRegion$inboundSchema))
     .optional(),
   stock_level: VirtualMachinePlansStockLevel$inboundSchema.optional(),
+  available_operating_systems: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "stock_level": "stockLevel",
+    "available_operating_systems": "availableOperatingSystems",
   });
 });
 /** @internal */
@@ -732,6 +738,7 @@ export type VirtualMachinePlansAttributes$Outbound = {
   specs?: VirtualMachinePlansSpecs$Outbound | undefined;
   regions?: Array<VirtualMachinePlansRegion$Outbound> | undefined;
   stock_level?: string | undefined;
+  available_operating_systems?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -745,9 +752,11 @@ export const VirtualMachinePlansAttributes$outboundSchema: z.ZodType<
   regions: z.array(z.lazy(() => VirtualMachinePlansRegion$outboundSchema))
     .optional(),
   stockLevel: VirtualMachinePlansStockLevel$outboundSchema.optional(),
+  availableOperatingSystems: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     stockLevel: "stock_level",
+    availableOperatingSystems: "available_operating_systems",
   });
 });
 

package/src/models/virtualmachines.ts

@@ -0,0 +1,94 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  VirtualMachineAttributes,
+  VirtualMachineAttributes$inboundSchema,
+  VirtualMachineAttributes$Outbound,
+  VirtualMachineAttributes$outboundSchema,
+} from "./virtualmachineattributes.js";
+
+export type VirtualMachinesMeta = {};
+
+export type VirtualMachines = {
+  data?: Array<VirtualMachineAttributes> | undefined;
+  meta?: VirtualMachinesMeta | undefined;
+};
+
+/** @internal */
+export const VirtualMachinesMeta$inboundSchema: z.ZodType<
+  VirtualMachinesMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type VirtualMachinesMeta$Outbound = {};
+
+/** @internal */
+export const VirtualMachinesMeta$outboundSchema: z.ZodType<
+  VirtualMachinesMeta$Outbound,
+  z.ZodTypeDef,
+  VirtualMachinesMeta
+> = z.object({});
+
+export function virtualMachinesMetaToJSON(
+  virtualMachinesMeta: VirtualMachinesMeta,
+): string {
+  return JSON.stringify(
+    VirtualMachinesMeta$outboundSchema.parse(virtualMachinesMeta),
+  );
+}
+export function virtualMachinesMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachinesMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachinesMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachinesMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const VirtualMachines$inboundSchema: z.ZodType<
+  VirtualMachines,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(VirtualMachineAttributes$inboundSchema).optional(),
+  meta: z.lazy(() => VirtualMachinesMeta$inboundSchema).optional(),
+});
+/** @internal */
+export type VirtualMachines$Outbound = {
+  data?: Array<VirtualMachineAttributes$Outbound> | undefined;
+  meta?: VirtualMachinesMeta$Outbound | undefined;
+};
+
+/** @internal */
+export const VirtualMachines$outboundSchema: z.ZodType<
+  VirtualMachines$Outbound,
+  z.ZodTypeDef,
+  VirtualMachines
+> = z.object({
+  data: z.array(VirtualMachineAttributes$outboundSchema).optional(),
+  meta: z.lazy(() => VirtualMachinesMeta$outboundSchema).optional(),
+});
+
+export function virtualMachinesToJSON(
+  virtualMachines: VirtualMachines,
+): string {
+  return JSON.stringify(VirtualMachines$outboundSchema.parse(virtualMachines));
+}
+export function virtualMachinesFromJSON(
+  jsonString: string,
+): SafeParseResult<VirtualMachines, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VirtualMachines$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VirtualMachines' from JSON`,
+  );
+}

package/src/sdk/kubernetesclusters.ts

@@ -34,9 +34,7 @@ export class KubernetesClusters extends ClientSDK {
    * Create a Kubernetes Cluster
    *
    * @remarks
-   * Creates a new managed Kubernetes cluster. The cluster will be provisioned using Cluster API (CAPI) on the Management Cluster.
-   *
-   * **Note:** This feature requires the `managed_k8s_clusters_api` feature flag to be enabled for your team. Maximum of 1 cluster per project.
+   * Creates a new managed Kubernetes cluster. Maximum of 1 cluster per project.
    *
    * 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.
    */
@@ -55,7 +53,7 @@ export class KubernetesClusters extends ClientSDK {
    * Get a Kubernetes Cluster
    *
    * @remarks
-   * Retrieves detailed information about a Kubernetes cluster including its status, control plane, and worker node details.
+   * Retrieves detailed information about a Kubernetes cluster including its status, control plane, worker node details, and individual node information.
    */
   async getKubernetesCluster(
     request: operations.GetKubernetesClusterRequest,

package/src/sdk/storage.ts

@@ -4,14 +4,19 @@
 
 import { storageCreateFilesystem } from "../funcs/storageCreateFilesystem.js";
 import { storageDeleteFilesystem } from "../funcs/storageDeleteFilesystem.js";
+import { storageDeleteStorageObjects } from "../funcs/storageDeleteStorageObjects.js";
 import { storageDeleteStorageVolumes } from "../funcs/storageDeleteStorageVolumes.js";
+import { storageGetStorageObject } from "../funcs/storageGetStorageObject.js";
+import { storageGetStorageObjects } from "../funcs/storageGetStorageObjects.js";
 import { storageGetStorageVolume } from "../funcs/storageGetStorageVolume.js";
 import { storageGetStorageVolumes } from "../funcs/storageGetStorageVolumes.js";
 import { storageListFilesystems } from "../funcs/storageListFilesystems.js";
+import { storagePostStorageObjects } from "../funcs/storagePostStorageObjects.js";
 import { storagePostStorageVolumes } from "../funcs/storagePostStorageVolumes.js";
 import { storagePostStorageVolumesMount } from "../funcs/storagePostStorageVolumesMount.js";
 import { storageUpdateFilesystem } from "../funcs/storageUpdateFilesystem.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";
 
@@ -168,4 +173,72 @@ export class Storage extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * List object storages
+   *
+   * @remarks
+   * Lists all object storages from a team.
+   */
+  async getStorageObjects(
+    request?: operations.GetStorageObjectsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ObjectStorages> {
+    return unwrapAsync(storageGetStorageObjects(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create object storage
+   *
+   * @remarks
+   * Creates a new object storage bucket for a project.
+   */
+  async postStorageObjects(
+    request: operations.PostStorageObjectsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostStorageObjectsResponse> {
+    return unwrapAsync(storagePostStorageObjects(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve object storage
+   *
+   * @remarks
+   * Shows details of a specific object storage.
+   */
+  async getStorageObject(
+    request: operations.GetStorageObjectRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetStorageObjectResponse> {
+    return unwrapAsync(storageGetStorageObject(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete object storage
+   *
+   * @remarks
+   * Allows you to remove an object storage from a project.
+   */
+  async deleteStorageObjects(
+    request: operations.DeleteStorageObjectsRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(storageDeleteStorageObjects(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/virtualmachines.ts

@@ -40,7 +40,7 @@ export class VirtualMachines extends ClientSDK {
   async list(
     request?: operations.IndexVirtualMachineRequest | undefined,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<models.VirtualMachines> {
     return unwrapAsync(virtualMachinesList(
       this,
       request,
@@ -57,7 +57,7 @@ export class VirtualMachines extends ClientSDK {
   async get(
     request: operations.ShowVirtualMachineRequest,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<models.VirtualMachine> {
     return unwrapAsync(virtualMachinesGet(
       this,
       request,