@phala/cloud 0.1.2 → 0.2.0

package/dist/actions/cvms/get_available_os_images.d.ts

@@ -0,0 +1,217 @@
+import { z } from "zod";
+import { type CvmIdInput } from "../../types/cvm_id";
+/**
+ * OS image variant (prod or dev)
+ */
+export declare const OSImageVariantSchema: z.ZodObject<{
+    name: z.ZodString;
+    os_image_hash: z.ZodNullable<z.ZodString>;
+    is_current: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    os_image_hash: string | null;
+    is_current: boolean;
+}, {
+    name: string;
+    os_image_hash: string | null;
+    is_current: boolean;
+}>;
+export type OSImageVariant = z.infer<typeof OSImageVariantSchema>;
+/**
+ * Available OS image information with prod/dev variants
+ */
+export declare const AvailableOSImageSchema: z.ZodObject<{
+    version: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>;
+    prod: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        os_image_hash: z.ZodNullable<z.ZodString>;
+        is_current: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }>>;
+    dev: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        os_image_hash: z.ZodNullable<z.ZodString>;
+        is_current: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: [number, number, number] | [number, number, number, number];
+    prod: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+    dev: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+}, {
+    version: [number, number, number] | [number, number, number, number];
+    prod: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+    dev: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+}>;
+export type AvailableOSImage = z.infer<typeof AvailableOSImageSchema>;
+/**
+ * Response schema for available OS images
+ */
+export declare const GetAvailableOSImagesResponseSchema: z.ZodArray<z.ZodObject<{
+    version: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>;
+    prod: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        os_image_hash: z.ZodNullable<z.ZodString>;
+        is_current: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }>>;
+    dev: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        os_image_hash: z.ZodNullable<z.ZodString>;
+        is_current: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }, {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: [number, number, number] | [number, number, number, number];
+    prod: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+    dev: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+}, {
+    version: [number, number, number] | [number, number, number, number];
+    prod: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+    dev: {
+        name: string;
+        os_image_hash: string | null;
+        is_current: boolean;
+    } | null;
+}>, "many">;
+export type GetAvailableOSImagesResponse = z.infer<typeof GetAvailableOSImagesResponseSchema>;
+export declare const GetAvailableOSImagesRequestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    uuid: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+    instance_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}, {
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}>, any, any>, {
+    cvmId: string;
+}, any>;
+export type GetAvailableOSImagesRequest = CvmIdInput;
+/**
+ * Get available OS images for CVM upgrade
+ *
+ * Returns list of OS images that this CVM can upgrade to.
+ * The response includes only images that:
+ * 1. Are deployed on the CVM's teepod
+ * 2. Are allowed by the CVM's KMS if applicable
+ * 3. Follow dev/non-dev upgrade rules
+ * 4. Match GPU requirements
+ *
+ * @param client - The API client
+ * @param request - Request parameters
+ * @param request.cvmId - ID of the CVM
+ * @returns Array of available OS images grouped by version
+ *
+ * @example
+ * ```typescript
+ * const images = await getAvailableOsImages(client, { cvmId: "cvm-123" })
+ * console.log(images[0].version) // [0, 3, 5]
+ * console.log(images[0].prod?.name) // "prod-0.3.5"
+ * console.log(images[0].dev?.name) // "dev-0.3.5"
+ * ```
+ */
+declare const getAvailableOsImages: {
+    (client: import("../..").BaseClient, params: CvmIdInput): Promise<{
+        version: [number, number, number] | [number, number, number, number];
+        prod: {
+            name: string;
+            os_image_hash: string | null;
+            is_current: boolean;
+        } | null;
+        dev: {
+            name: string;
+            os_image_hash: string | null;
+            is_current: boolean;
+        } | null;
+    }[]>;
+    <T extends z.ZodTypeAny>(client: import("../..").BaseClient, params: CvmIdInput, parameters: {
+        schema: T;
+    }): Promise<z.TypeOf<T>>;
+    (client: import("../..").BaseClient, params: CvmIdInput, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+}, safeGetAvailableOsImages: {
+    (client: import("../..").BaseClient, params: CvmIdInput): Promise<import("../..").SafeResult<{
+        version: [number, number, number] | [number, number, number, number];
+        prod: {
+            name: string;
+            os_image_hash: string | null;
+            is_current: boolean;
+        } | null;
+        dev: {
+            name: string;
+            os_image_hash: string | null;
+            is_current: boolean;
+        } | null;
+    }[]>>;
+    <T extends z.ZodTypeAny>(client: import("../..").BaseClient, params: CvmIdInput, parameters: {
+        schema: T;
+    }): Promise<import("../..").SafeResult<z.TypeOf<T>>>;
+    (client: import("../..").BaseClient, params: CvmIdInput, parameters: {
+        schema: false;
+    }): Promise<import("../..").SafeResult<unknown>>;
+};
+export { getAvailableOsImages, safeGetAvailableOsImages };

package/dist/actions/cvms/get_cvm_state.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { type Client } from "../../client";
+import { type CvmIdInput } from "../../types/cvm_id";
+/**
+ * CVM state response schema
+ */
+export declare const CvmStateSchema: z.ZodObject<{
+    status: z.ZodString;
+    derived_status: z.ZodOptional<z.ZodString>;
+    vm_uuid: z.ZodOptional<z.ZodString>;
+    instance_id: z.ZodOptional<z.ZodString>;
+    uptime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    uptime?: string | undefined;
+    instance_id?: string | undefined;
+    vm_uuid?: string | undefined;
+    derived_status?: string | undefined;
+}, {
+    status: string;
+    uptime?: string | undefined;
+    instance_id?: string | undefined;
+    vm_uuid?: string | undefined;
+    derived_status?: string | undefined;
+}>;
+export type CvmState = z.infer<typeof CvmStateSchema>;
+export declare const GetCvmStateRequestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    uuid: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+    instance_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}, {
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}>, any, any>, {
+    cvmId: string;
+}, any>;
+export type GetCvmStateRequest = CvmIdInput;
+/**
+ * Get current state of a CVM (one-shot, immediate return)
+ *
+ * This action retrieves the current state of a CVM without waiting or streaming.
+ * For monitoring state changes until a target status is reached, use `watchCvmState` instead.
+ *
+ * @param client - The API client
+ * @param request - Request parameters
+ * @param request.cvmId - ID of the CVM to get state for
+ * @param parameters - Optional behavior parameters
+ * @returns Current CVM state
+ *
+ * @example
+ * ```typescript
+ * const state = await getCvmState(client, { cvmId: "cvm-123" })
+ * console.log(state.status) // "running", "stopped", etc.
+ * ```
+ */
+declare const getCvmState: {
+    (client: Client, params: CvmIdInput): Promise<{
+        status: string;
+        uptime?: string | undefined;
+        instance_id?: string | undefined;
+        vm_uuid?: string | undefined;
+        derived_status?: string | undefined;
+    }>;
+    <T extends z.ZodTypeAny>(client: Client, params: CvmIdInput, parameters: {
+        schema: T;
+    }): Promise<z.TypeOf<T>>;
+    (client: Client, params: CvmIdInput, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+}, safeGetCvmState: {
+    (client: Client, params: CvmIdInput): Promise<import("../..").SafeResult<{
+        status: string;
+        uptime?: string | undefined;
+        instance_id?: string | undefined;
+        vm_uuid?: string | undefined;
+        derived_status?: string | undefined;
+    }>>;
+    <T extends z.ZodTypeAny>(client: Client, params: CvmIdInput, parameters: {
+        schema: T;
+    }): Promise<import("../..").SafeResult<z.TypeOf<T>>>;
+    (client: Client, params: CvmIdInput, parameters: {
+        schema: false;
+    }): Promise<import("../..").SafeResult<unknown>>;
+};
+export { getCvmState, safeGetCvmState };

package/dist/actions/cvms/update_os_image.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/**
+ * Update CVM OS image
+ *
+ * This action initiates an asynchronous OS image update operation.
+ * The CVM will be shut down, the OS image updated, and then restarted.
+ * This operation may take several minutes to complete.
+ *
+ * Returns 202 Accepted as the operation runs asynchronously.
+ *
+ * @example
+ * ```typescript
+ * import { createClient, updateOsImage } from '@phala/cloud'
+ *
+ * const client = createClient();
+ * await updateOsImage(client, {
+ *   id: 'my-cvm-id',
+ *   os_image_name: 'prod-0.3.5'
+ * });
+ * console.log('OS image update initiated');
+ * ```
+ */
+export declare const UpdateOsImageRequestSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    uuid: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+    instance_id: z.ZodOptional<z.ZodString>;
+} & {
+    os_image_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    os_image_name: string;
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}, {
+    os_image_name: string;
+    id?: string | undefined;
+    app_id?: string | undefined;
+    instance_id?: string | undefined;
+    uuid?: string | undefined;
+}>, any, any>;
+export type UpdateOsImageRequest = z.infer<typeof UpdateOsImageRequestSchema>;
+declare const updateOsImage: {
+    (client: import("../..").BaseClient, params?: any): Promise<void>;
+    <T extends z.ZodTypeAny>(client: import("../..").BaseClient, params?: any, parameters?: {
+        schema: T;
+    } | undefined): Promise<z.TypeOf<T>>;
+    (client: import("../..").BaseClient, params?: any, parameters?: {
+        schema: false;
+    } | undefined): Promise<unknown>;
+}, safeUpdateOsImage: {
+    (client: import("../..").BaseClient, params?: any): Promise<import("../..").SafeResult<void>>;
+    <T extends z.ZodTypeAny>(client: import("../..").BaseClient, params?: any, parameters?: {
+        schema: T;
+    } | undefined): Promise<import("../..").SafeResult<z.TypeOf<T>>>;
+    (client: import("../..").BaseClient, params?: any, parameters?: {
+        schema: false;
+    } | undefined): Promise<import("../..").SafeResult<unknown>>;
+};
+export { updateOsImage, safeUpdateOsImage };

package/dist/actions/cvms/watch_cvm_state.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import { type Client } from "../../client";
+import { type CvmIdInput } from "../../types/cvm_id";
+import { type CvmState } from "./get_cvm_state";
+/**
+ * SSE event data structures
+ */
+type SSEStateEvent = {
+    type: "state";
+    data: CvmState;
+};
+type SSECompleteEvent = {
+    type: "complete";
+    data: {
+        status: string;
+        elapsed: number;
+        target: string;
+    };
+};
+type SSETimeoutEvent = {
+    type: "timeout";
+    data: {
+        error: string;
+        elapsed: number;
+        target: string;
+    };
+};
+type SSEErrorEvent = {
+    type: "error";
+    data: {
+        error: string;
+        elapsed?: number;
+        message?: string;
+    };
+};
+export type SSEEvent = SSEStateEvent | SSECompleteEvent | SSETimeoutEvent | SSEErrorEvent;
+/**
+ * Watch CVM state request input (before transformation)
+ */
+export type WatchCvmStateRequest = CvmIdInput & {
+    target: string;
+    interval?: number;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+};
+export declare const WatchCvmStateRequestSchema: z.ZodObject<{
+    target: z.ZodString;
+    interval: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    retryDelay: number;
+    maxRetries: number;
+    target: string;
+    interval: number;
+}, {
+    target: string;
+    timeout?: number | undefined;
+    retryDelay?: number | undefined;
+    maxRetries?: number | undefined;
+    interval?: number | undefined;
+}>;
+/**
+ * Options for watch operation
+ */
+export interface WatchCvmStateOptions {
+    signal?: AbortSignal;
+    onEvent?: (event: SSEEvent) => void;
+}
+/**
+ * Error thrown when watch operation is aborted
+ */
+export declare class WatchAbortedError extends Error {
+    constructor();
+}
+/**
+ * Error thrown when max retries exceeded
+ */
+export declare class MaxRetriesExceededError extends Error {
+    readonly attempts: number;
+    constructor(attempts: number);
+}
+/**
+ * Watch CVM state changes using Server-Sent Events (SSE)
+ *
+ * This action streams state updates from the backend until the target status is reached,
+ * timeout occurs, or an error happens. It automatically retries on timeout/error up to
+ * maxRetries times, providing unlimited watch capability.
+ *
+ * Key features:
+ * - Streams real-time state updates via SSE
+ * - Automatic retry on timeout (backend max 600s, but SDK can retry infinitely)
+ * - AbortController support for cancellation
+ * - Callback for each SSE event
+ * - Resolves with final state when target reached
+ *
+ * @param client - The API client
+ * @param request - Request parameters
+ * @param request.id - CVM ID (or use uuid, app_id, instance_id)
+ * @param request.target - Target status to wait for (e.g., "running")
+ * @param request.interval - Polling interval in seconds (5-30, default: 5)
+ * @param request.timeout - Timeout per attempt in seconds (10-600, default: 300)
+ * @param request.maxRetries - Max retry attempts (default: Infinity)
+ * @param request.retryDelay - Delay between retries in ms (default: 5000)
+ * @param options - Optional behavior parameters
+ * @param options.signal - AbortSignal for cancellation
+ * @param options.onEvent - Callback invoked for each SSE event
+ * @returns Promise that resolves with final CVM state when target is reached
+ *
+ * @throws {WatchAbortedError} If operation is aborted via signal
+ * @throws {MaxRetriesExceededError} If max retries exceeded without reaching target
+ * @throws {Error} For other unexpected errors
+ *
+ * @example
+ * ```typescript
+ * // Basic usage: wait for CVM to reach "running" status
+ * const state = await watchCvmState(client, {
+ *   id: "cvm-123",
+ *   target: "running"
+ * })
+ * console.log("CVM is now running!")
+ *
+ * // With event callback and abort controller
+ * const controller = new AbortController()
+ * try {
+ *   const state = await watchCvmState(
+ *     client,
+ *     {
+ *       id: "cvm-123",
+ *       target: "running",
+ *       interval: 10,
+ *       maxRetries: 5
+ *     },
+ *     {
+ *       signal: controller.signal,
+ *       onEvent: (event) => {
+ *         if (event.type === "state") {
+ *           console.log("Current status:", event.data.status)
+ *         }
+ *       }
+ *     }
+ *   )
+ * } catch (error) {
+ *   if (error instanceof WatchAbortedError) {
+ *     console.log("Watch cancelled")
+ *   }
+ * }
+ *
+ * // Cancel after 30 seconds
+ * setTimeout(() => controller.abort(), 30000)
+ * ```
+ */
+export declare function watchCvmState(client: Client, request: WatchCvmStateRequest, options?: WatchCvmStateOptions): Promise<CvmState>;
+export {};

package/dist/actions/get_available_nodes.d.ts

@@ -637,6 +637,12 @@ export type TeepodCapacity = z.infer<typeof TeepodCapacitySchema>;
 export type ResourceThreshold = z.infer<typeof ResourceThresholdSchema>;
 export type AvailableNodes = z.infer<typeof AvailableNodesSchema>;
 declare const getAvailableNodes: {
+    (client: Client, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    <T extends z.ZodTypeAny>(client: Client, parameters: {
+        schema: T;
+    }): Promise<z.TypeOf<T>>;
     (client: Client): Promise<z.objectOutputType<{
         tier: z.ZodString;
         capacity: z.ZodObject<{
@@ -788,13 +794,13 @@ declare const getAvailableNodes: {
             gateway_app_id: z.ZodEffects<z.ZodNullable<z.ZodString>, `0x${string}`, string | null>;
         }, z.ZodTypeAny, "passthrough">>, "many">;
     }, z.ZodTypeAny, "passthrough">>;
-    <T extends z.ZodTypeAny>(client: Client, parameters: {
-        schema: T;
-    }): Promise<z.TypeOf<T>>;
+}, safeGetAvailableNodes: {
     (client: Client, parameters: {
         schema: false;
-    }): Promise<unknown>;
-}, safeGetAvailableNodes: {
+    }): Promise<import("..").SafeResult<unknown>>;
+    <T extends z.ZodTypeAny>(client: Client, parameters: {
+        schema: T;
+    }): Promise<import("..").SafeResult<z.TypeOf<T>>>;
     (client: Client): Promise<import("..").SafeResult<z.objectOutputType<{
         tier: z.ZodString;
         capacity: z.ZodObject<{
@@ -946,11 +952,5 @@ declare const getAvailableNodes: {
             gateway_app_id: z.ZodEffects<z.ZodNullable<z.ZodString>, `0x${string}`, string | null>;
         }, z.ZodTypeAny, "passthrough">>, "many">;
     }, z.ZodTypeAny, "passthrough">>>;
-    <T extends z.ZodTypeAny>(client: Client, parameters: {
-        schema: T;
-    }): Promise<import("..").SafeResult<z.TypeOf<T>>>;
-    (client: Client, parameters: {
-        schema: false;
-    }): Promise<import("..").SafeResult<unknown>>;
 };
 export { getAvailableNodes, safeGetAvailableNodes };

package/dist/actions/get_current_user.d.ts

@@ -85,6 +85,12 @@ export declare const CurrentUserSchema: z.ZodObject<{
 }, z.ZodTypeAny, "passthrough">>;
 export type CurrentUser = z.infer<typeof CurrentUserSchema>;
 declare const getCurrentUser: {
+    (client: Client, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    <T extends z.ZodTypeAny>(client: Client, parameters: {
+        schema: T;
+    }): Promise<z.TypeOf<T>>;
     (client: Client): Promise<z.objectOutputType<{
         username: z.ZodString;
         email: z.ZodString;
@@ -94,13 +100,13 @@ declare const getCurrentUser: {
         team_name: z.ZodString;
         team_tier: z.ZodString;
     }, z.ZodTypeAny, "passthrough">>;
-    <T extends z.ZodTypeAny>(client: Client, parameters: {
-        schema: T;
-    }): Promise<z.TypeOf<T>>;
+}, safeGetCurrentUser: {
     (client: Client, parameters: {
         schema: false;
-    }): Promise<unknown>;
-}, safeGetCurrentUser: {
+    }): Promise<import("..").SafeResult<unknown>>;
+    <T extends z.ZodTypeAny>(client: Client, parameters: {
+        schema: T;
+    }): Promise<import("..").SafeResult<z.TypeOf<T>>>;
     (client: Client): Promise<import("..").SafeResult<z.objectOutputType<{
         username: z.ZodString;
         email: z.ZodString;
@@ -110,11 +116,5 @@ declare const getCurrentUser: {
         team_name: z.ZodString;
         team_tier: z.ZodString;
     }, z.ZodTypeAny, "passthrough">>>;
-    <T extends z.ZodTypeAny>(client: Client, parameters: {
-        schema: T;
-    }): Promise<import("..").SafeResult<z.TypeOf<T>>>;
-    (client: Client, parameters: {
-        schema: false;
-    }): Promise<import("..").SafeResult<unknown>>;
 };
 export { getCurrentUser, safeGetCurrentUser };

package/dist/actions/index.d.ts

@@ -12,6 +12,7 @@ export { getCvmInfo, safeGetCvmInfo, CvmLegacyDetailSchema, GetCvmInfoRequestSch
 export { getCvmList, safeGetCvmList, GetCvmListSchema, GetCvmListRequestSchema, type GetCvmListRequest, type GetCvmListResponse, } from "./cvms/get_cvm_list";
 export { getKmsInfo, safeGetKmsInfo, GetKmsInfoRequestSchema, type GetKmsInfoRequest, } from "./kms/get_kms_info";
 export { getKmsList, safeGetKmsList, GetKmsListSchema, GetKmsListRequestSchema, type GetKmsListRequest, type GetKmsListResponse, } from "./kms/get_kms_list";
+export { nextAppIds, safeNextAppIds, NextAppIdsSchema, NextAppIdsRequestSchema, type NextAppIdsRequest, type NextAppIds, } from "./kms/next_app_ids";
 export { listWorkspaces, safeListWorkspaces, WorkspaceResponseSchema, ListWorkspacesSchema, PaginationMetadataSchema, type WorkspaceResponse, type ListWorkspaces, type PaginationMetadata, type ListWorkspacesRequest, } from "./workspaces/list_workspaces";
 export { getWorkspace, safeGetWorkspace, } from "./workspaces/get_workspace";
 export { listInstanceTypes, safeListInstanceTypes, PaginatedInstanceTypesSchema, InstanceTypeSchema, type PaginatedInstanceTypes, type InstanceType, type ListInstanceTypesRequest, ListInstanceTypesRequestSchema, } from "./list-instance-types";
@@ -23,7 +24,11 @@ export { deleteCvm, safeDeleteCvm, DeleteCvmRequestSchema, type DeleteCvmRequest
 export { getCvmStats, safeGetCvmStats, CvmSystemInfoSchema, GetCvmStatsRequestSchema, type GetCvmStatsRequest, type CvmSystemInfo, } from "./cvms/get_cvm_stats";
 export { getCvmContainersStats, safeGetCvmContainersStats, CvmContainersStatsSchema, GetCvmContainersStatsRequestSchema, type GetCvmContainersStatsRequest, type CvmContainersStats, } from "./cvms/get_cvm_containers_stats";
 export { getCvmNetwork, safeGetCvmNetwork, CvmNetworkSchema, GetCvmNetworkRequestSchema, type GetCvmNetworkRequest, type CvmNetwork, } from "./cvms/get_cvm_network";
+export { getCvmState, safeGetCvmState, CvmStateSchema, GetCvmStateRequestSchema, type GetCvmStateRequest, type CvmState, } from "./cvms/get_cvm_state";
+export { watchCvmState, WatchCvmStateRequestSchema, type WatchCvmStateRequest, type WatchCvmStateOptions, type SSEEvent, WatchAbortedError, MaxRetriesExceededError, } from "./cvms/watch_cvm_state";
 export { getCvmAttestation, safeGetCvmAttestation, CvmAttestationSchema, GetCvmAttestationRequestSchema, type GetCvmAttestationRequest, type CvmAttestation, } from "./cvms/get_cvm_attestation";
 export { getCvmDockerCompose, safeGetCvmDockerCompose, GetCvmDockerComposeRequestSchema, type GetCvmDockerComposeRequest, } from "./cvms/get_cvm_docker_compose";
 export { updateCvmResources, safeUpdateCvmResources, UpdateCvmResourcesRequestSchema, type UpdateCvmResourcesRequest, } from "./cvms/update_cvm_resources";
 export { updateCvmVisibility, safeUpdateCvmVisibility, UpdateCvmVisibilityRequestSchema, type UpdateCvmVisibilityRequest, } from "./cvms/update_cvm_visibility";
+export { getAvailableOsImages, safeGetAvailableOsImages, OSImageVariantSchema, GetAvailableOSImagesResponseSchema, GetAvailableOSImagesRequestSchema, type OSImageVariant, type GetAvailableOSImagesResponse, type GetAvailableOSImagesRequest, } from "./cvms/get_available_os_images";
+export { updateOsImage, safeUpdateOsImage, UpdateOsImageRequestSchema, type UpdateOsImageRequest, } from "./cvms/update_os_image";