@phala/cloud 0.0.9 → 0.0.11

package/dist/index.js

@@ -45,12 +45,15 @@ __export(index_exports, {
   DeployAppAuthRequestSchema: () => DeployAppAuthRequestSchema,
   DeployAppAuthSchema: () => DeployAppAuthSchema,
   GetAppEnvEncryptPubKeySchema: () => GetAppEnvEncryptPubKeySchema,
-  GetCvmComposeFileResultSchema: () => GetCvmComposeFileResultSchema,
   GetCvmListSchema: () => GetCvmListSchema,
   GetKmsListSchema: () => GetKmsListSchema,
+  InstanceTypeSchema: () => InstanceTypeSchema,
   KmsInfoSchema: () => KmsInfoSchema,
+  ListWorkspacesSchema: () => ListWorkspacesSchema,
   ManagedUserSchema: () => ManagedUserSchema,
   NetworkError: () => NetworkError,
+  PaginatedInstanceTypesSchema: () => PaginatedInstanceTypesSchema,
+  PaginationMetadataSchema: () => PaginationMetadataSchema,
   ProvisionCvmComposeFileUpdateRequestSchema: () => ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema: () => ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema: () => ProvisionCvmRequestSchema,
@@ -60,6 +63,7 @@ __export(index_exports, {
   TransactionError: () => TransactionError,
   VmInfoSchema: () => VmInfoSchema,
   WalletError: () => WalletError,
+  WorkspaceResponseSchema: () => WorkspaceResponseSchema,
   addComposeHash: () => addComposeHash,
   addNetwork: () => addNetwork,
   asHex: () => asHex,
@@ -90,6 +94,9 @@ __export(index_exports, {
   getErrorMessage: () => getErrorMessage,
   getKmsInfo: () => getKmsInfo,
   getKmsList: () => getKmsList,
+  getWorkspace: () => getWorkspace,
+  listInstanceTypes: () => listInstanceTypes,
+  listWorkspaces: () => listWorkspaces,
   parseEnv: () => parseEnv,
   parseEnvVars: () => parseEnvVars,
   provisionCvm: () => provisionCvm,
@@ -106,6 +113,9 @@ __export(index_exports, {
   safeGetCvmList: () => safeGetCvmList,
   safeGetKmsInfo: () => safeGetKmsInfo,
   safeGetKmsList: () => safeGetKmsList,
+  safeGetWorkspace: () => safeGetWorkspace,
+  safeListInstanceTypes: () => safeListInstanceTypes,
+  safeListWorkspaces: () => safeListWorkspaces,
   safeProvisionCvm: () => safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate: () => safeProvisionCvmComposeFileUpdate,
   safeValidateActionParameters: () => safeValidateActionParameters,
@@ -224,22 +234,31 @@ var Client = class {
     };
     const version = resolvedConfig.version && SUPPORTED_API_VERSIONS.includes(resolvedConfig.version) ? resolvedConfig.version : SUPPORTED_API_VERSIONS[0];
     this.config = resolvedConfig;
-    if (!resolvedConfig.apiKey) {
+    if (!resolvedConfig.useCookieAuth && !resolvedConfig.apiKey) {
       throw new Error(
         "API key is required. Provide it via config.apiKey or set PHALA_CLOUD_API_KEY environment variable."
       );
     }
-    const { apiKey, baseURL, timeout, headers, ...fetchOptions } = resolvedConfig;
+    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = resolvedConfig;
     const requestHeaders = {
-      "X-API-Key": apiKey,
       "X-Phala-Version": version,
-      "Content-Type": "application/json",
-      ...headers || {}
+      "Content-Type": "application/json"
     };
+    if (headers && typeof headers === "object") {
+      Object.entries(headers).forEach(([key, value]) => {
+        if (typeof value === "string") {
+          requestHeaders[key] = value;
+        }
+      });
+    }
+    if (!useCookieAuth && apiKey) {
+      requestHeaders["X-API-Key"] = apiKey;
+    }
     this.fetchInstance = import_ofetch.ofetch.create({
       baseURL,
       timeout: timeout || 3e4,
       headers: requestHeaders,
+      ...useCookieAuth ? { credentials: "include" } : {},
       ...fetchOptions,
       // Log request in cURL format
       onRequest({ request, options }) {
@@ -290,6 +309,9 @@ var Client = class {
             formatResponse(response.status, response.statusText, response.headers, response._data)
           );
         }
+        if (onResponseError) {
+          onResponseError({ request, response, options });
+        }
       }
     });
   }
@@ -1227,7 +1249,10 @@ var import_zod5 = require("zod");
 var AvailableOSImageSchema = import_zod5.z.object({
   name: import_zod5.z.string(),
   is_dev: import_zod5.z.boolean(),
-  version: import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()]),
+  version: import_zod5.z.union([
+    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()]),
+    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()])
+  ]),
   os_image_hash: import_zod5.z.string().nullable().optional()
 }).passthrough();
 var TeepodCapacitySchema = import_zod5.z.object({
@@ -2067,8 +2092,11 @@ async function safeAddComposeHash(request, parameters) {
 }
 
 // src/actions/get_cvm_compose_file.ts
+var import_zod11 = require("zod");
+
+// src/types/app_compose.ts
 var import_zod10 = require("zod");
-var GetCvmComposeFileResultSchema = import_zod10.z.object({
+var LooseAppComposeSchema = import_zod10.z.object({
   allowed_envs: import_zod10.z.array(import_zod10.z.string()).optional(),
   docker_compose_file: import_zod10.z.string(),
   features: import_zod10.z.array(import_zod10.z.string()).optional(),
@@ -2080,14 +2108,16 @@ var GetCvmComposeFileResultSchema = import_zod10.z.object({
   tproxy_enabled: import_zod10.z.boolean().optional(),
   pre_launch_script: import_zod10.z.string().optional()
 }).passthrough();
-var GetCvmComposeFileRequestSchema = import_zod10.z.object({
-  id: import_zod10.z.string().optional(),
-  uuid: import_zod10.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod10.z.string().refine(
+
+// src/actions/get_cvm_compose_file.ts
+var GetCvmComposeFileRequestSchema = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  uuid: import_zod11.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod11.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod10.z.string().refine(
+  instance_id: import_zod11.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
@@ -2104,7 +2134,7 @@ async function getCvmComposeFile(client, request, parameters) {
   if (parameters?.schema === false) {
     return response;
   }
-  const schema = parameters?.schema || GetCvmComposeFileResultSchema;
+  const schema = parameters?.schema || LooseAppComposeSchema;
   return schema.parse(response);
 }
 async function safeGetCvmComposeFile(client, request, parameters) {
@@ -2119,44 +2149,38 @@ async function safeGetCvmComposeFile(client, request, parameters) {
   if (parameters?.schema === false) {
     return { success: true, data: httpResult.data };
   }
-  const schema = parameters?.schema || GetCvmComposeFileResultSchema;
+  const schema = parameters?.schema || LooseAppComposeSchema;
   return schema.safeParse(httpResult.data);
 }
 
 // src/actions/provision_cvm_compose_file_update.ts
-var import_zod11 = require("zod");
-var ProvisionCvmComposeFileUpdateRequestSchema = import_zod11.z.object({
-  id: import_zod11.z.string().optional(),
-  uuid: import_zod11.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod11.z.string().refine(
+var import_zod12 = require("zod");
+var ProvisionCvmComposeFileUpdateRequestSchema = import_zod12.z.object({
+  id: import_zod12.z.string().optional(),
+  uuid: import_zod12.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod12.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod11.z.string().refine(
+  instance_id: import_zod12.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  app_compose: import_zod11.z.object({
-    allowed_envs: import_zod11.z.array(import_zod11.z.string()).optional(),
-    docker_compose_file: import_zod11.z.string().min(1, "Docker compose file is required"),
-    name: import_zod11.z.string(),
-    kms_enabled: import_zod11.z.boolean().optional(),
-    public_logs: import_zod11.z.boolean().optional(),
-    public_sysinfo: import_zod11.z.boolean().optional(),
-    pre_launch_script: import_zod11.z.string().optional()
-  })
+  app_compose: LooseAppComposeSchema,
+  update_env_vars: import_zod12.z.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
 ).transform((data) => ({
   cvmId: data.id || data.uuid || data.app_id || data.instance_id,
   request: data.app_compose,
+  update_env_vars: data.update_env_vars,
   _raw: data
 }));
-var ProvisionCvmComposeFileUpdateResultSchema = import_zod11.z.object({
-  app_id: import_zod11.z.string().nullable(),
-  device_id: import_zod11.z.string().nullable(),
-  compose_hash: import_zod11.z.string(),
+var ProvisionCvmComposeFileUpdateResultSchema = import_zod12.z.object({
+  app_id: import_zod12.z.string().nullable(),
+  device_id: import_zod12.z.string().nullable(),
+  compose_hash: import_zod12.z.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
 async function provisionCvmComposeFileUpdate(client, request, parameters) {
@@ -2191,21 +2215,22 @@ async function safeProvisionCvmComposeFileUpdate(client, request, parameters) {
 }
 
 // src/actions/commit_cvm_compose_file_update.ts
-var import_zod12 = require("zod");
-var CommitCvmComposeFileUpdateRequestSchema = import_zod12.z.object({
-  id: import_zod12.z.string().optional(),
-  uuid: import_zod12.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod12.z.string().refine(
+var import_zod13 = require("zod");
+var CommitCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
+  id: import_zod13.z.string().optional(),
+  uuid: import_zod13.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod13.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod12.z.string().refine(
+  instance_id: import_zod13.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  compose_hash: import_zod12.z.string().min(1, "Compose hash is required"),
-  encrypted_env: import_zod12.z.string().optional(),
-  env_keys: import_zod12.z.array(import_zod12.z.string()).optional()
+  compose_hash: import_zod13.z.string().min(1, "Compose hash is required"),
+  encrypted_env: import_zod13.z.string().optional(),
+  env_keys: import_zod13.z.array(import_zod13.z.string()).optional(),
+  update_env_vars: import_zod13.z.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -2214,9 +2239,10 @@ var CommitCvmComposeFileUpdateRequestSchema = import_zod12.z.object({
   compose_hash: data.compose_hash,
   encrypted_env: data.encrypted_env,
   env_keys: data.env_keys,
+  update_env_vars: !!data.update_env_vars,
   _raw: data
 }));
-var CommitCvmComposeFileUpdateSchema = import_zod12.z.any().transform(() => void 0);
+var CommitCvmComposeFileUpdateSchema = import_zod13.z.any().transform(() => void 0);
 async function commitCvmComposeFileUpdate(client, request, parameters) {
   const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
   const response = await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
@@ -2251,17 +2277,17 @@ async function safeCommitCvmComposeFileUpdate(client, request, parameters) {
 }
 
 // src/actions/get_app_env_encrypt_pubkey.ts
-var import_zod13 = require("zod");
-var GetAppEnvEncryptPubKeyRequestSchema = import_zod13.z.object({
-  kms: import_zod13.z.string().min(1, "KMS ID or slug is required"),
-  app_id: import_zod13.z.string().refine(
+var import_zod14 = require("zod");
+var GetAppEnvEncryptPubKeyRequestSchema = import_zod14.z.object({
+  kms: import_zod14.z.string().min(1, "KMS ID or slug is required"),
+  app_id: import_zod14.z.string().refine(
     (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
     "App ID must be exactly 40 characters or 42 characters with 0x prefix"
   )
 }).strict();
-var GetAppEnvEncryptPubKeySchema = import_zod13.z.object({
-  public_key: import_zod13.z.string(),
-  signature: import_zod13.z.string()
+var GetAppEnvEncryptPubKeySchema = import_zod14.z.object({
+  public_key: import_zod14.z.string(),
+  signature: import_zod14.z.string()
 }).strict();
 var getAppEnvEncryptPubKey = async (client, payload, parameters) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
@@ -2298,15 +2324,15 @@ var safeGetAppEnvEncryptPubKey = async (client, payload, parameters) => {
 };
 
 // src/actions/get_cvm_info.ts
-var import_zod14 = require("zod");
-var GetCvmInfoRequestSchema = import_zod14.z.object({
-  id: import_zod14.z.string().optional(),
-  uuid: import_zod14.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: import_zod14.z.string().refine(
+var import_zod15 = require("zod");
+var GetCvmInfoRequestSchema = import_zod15.z.object({
+  id: import_zod15.z.string().optional(),
+  uuid: import_zod15.z.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: import_zod15.z.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: import_zod14.z.string().refine(
+  instance_id: import_zod15.z.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional()
@@ -2352,18 +2378,18 @@ async function safeGetCvmInfo(client, request, parameters) {
 }
 
 // src/actions/get_cvm_list.ts
-var import_zod15 = require("zod");
-var GetCvmListRequestSchema = import_zod15.z.object({
-  page: import_zod15.z.number().int().min(1).optional(),
-  page_size: import_zod15.z.number().int().min(1).optional(),
-  node_id: import_zod15.z.number().int().min(1).optional()
+var import_zod16 = require("zod");
+var GetCvmListRequestSchema = import_zod16.z.object({
+  page: import_zod16.z.number().int().min(1).optional(),
+  page_size: import_zod16.z.number().int().min(1).optional(),
+  node_id: import_zod16.z.number().int().min(1).optional()
 }).strict();
-var GetCvmListSchema = import_zod15.z.object({
-  items: import_zod15.z.array(CvmInfoSchema),
-  total: import_zod15.z.number(),
-  page: import_zod15.z.number(),
-  page_size: import_zod15.z.number(),
-  pages: import_zod15.z.number()
+var GetCvmListSchema = import_zod16.z.object({
+  items: import_zod16.z.array(CvmInfoSchema),
+  total: import_zod16.z.number(),
+  page: import_zod16.z.number(),
+  page_size: import_zod16.z.number(),
+  pages: import_zod16.z.number()
 }).strict();
 async function getCvmList(client, request, parameters) {
   const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
@@ -2400,9 +2426,9 @@ async function safeGetCvmList(client, request, parameters) {
 }
 
 // src/actions/get_kms_info.ts
-var import_zod16 = require("zod");
-var GetKmsInfoRequestSchema = import_zod16.z.object({
-  kms_id: import_zod16.z.string().min(1, "KMS ID is required")
+var import_zod17 = require("zod");
+var GetKmsInfoRequestSchema = import_zod17.z.object({
+  kms_id: import_zod17.z.string().min(1, "KMS ID is required")
 });
 async function getKmsInfo(client, request, parameters) {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
@@ -2436,18 +2462,18 @@ async function safeGetKmsInfo(client, request, parameters) {
 }
 
 // src/actions/get_kms_list.ts
-var import_zod17 = require("zod");
-var GetKmsListRequestSchema = import_zod17.z.object({
-  page: import_zod17.z.number().int().min(1).optional(),
-  page_size: import_zod17.z.number().int().min(1).optional(),
-  is_onchain: import_zod17.z.boolean().optional()
+var import_zod18 = require("zod");
+var GetKmsListRequestSchema = import_zod18.z.object({
+  page: import_zod18.z.number().int().min(1).optional(),
+  page_size: import_zod18.z.number().int().min(1).optional(),
+  is_onchain: import_zod18.z.boolean().optional()
 }).strict();
-var GetKmsListSchema = import_zod17.z.object({
-  items: import_zod17.z.array(KmsInfoSchema),
-  total: import_zod17.z.number(),
-  page: import_zod17.z.number(),
-  page_size: import_zod17.z.number(),
-  pages: import_zod17.z.number()
+var GetKmsListSchema = import_zod18.z.object({
+  items: import_zod18.z.array(KmsInfoSchema),
+  total: import_zod18.z.number(),
+  page: import_zod18.z.number(),
+  page_size: import_zod18.z.number(),
+  pages: import_zod18.z.number()
 }).strict();
 async function getKmsList(client, request, parameters) {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
@@ -2483,6 +2509,148 @@ async function safeGetKmsList(client, request, parameters) {
   return validationResult;
 }
 
+// src/actions/workspaces/list_workspaces.ts
+var import_zod19 = require("zod");
+var WorkspaceResponseSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  name: import_zod19.z.string(),
+  slug: import_zod19.z.string().nullable(),
+  tier: import_zod19.z.string(),
+  role: import_zod19.z.string(),
+  created_at: import_zod19.z.string()
+}).passthrough();
+var PaginationMetadataSchema = import_zod19.z.object({
+  has_more: import_zod19.z.boolean(),
+  next_cursor: import_zod19.z.string().nullable(),
+  total: import_zod19.z.number().nullable()
+}).passthrough();
+var ListWorkspacesSchema = import_zod19.z.object({
+  data: import_zod19.z.array(WorkspaceResponseSchema),
+  pagination: PaginationMetadataSchema
+}).passthrough();
+async function listWorkspaces(client, parameters) {
+  validateActionParameters(parameters);
+  const queryParams = new URLSearchParams();
+  if (parameters?.cursor) queryParams.append("cursor", parameters.cursor);
+  if (parameters?.limit) queryParams.append("limit", parameters.limit.toString());
+  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
+  const response = await client.get(url);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || ListWorkspacesSchema;
+  return schema.parse(response);
+}
+async function safeListWorkspaces(client, parameters) {
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const queryParams = new URLSearchParams();
+  if (parameters?.cursor) queryParams.append("cursor", parameters.cursor);
+  if (parameters?.limit) queryParams.append("limit", parameters.limit.toString());
+  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
+  const httpResult = await client.safeGet(url);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || ListWorkspacesSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/workspaces/get_workspace.ts
+async function getWorkspace(client, teamSlug, parameters) {
+  validateActionParameters(parameters);
+  const response = await client.get(`/workspaces/${teamSlug}`);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || WorkspaceResponseSchema;
+  return schema.parse(response);
+}
+async function safeGetWorkspace(client, teamSlug, parameters) {
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const httpResult = await client.safeGet(`/workspaces/${teamSlug}`);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return { success: true, data: httpResult.data };
+  }
+  const schema = parameters?.schema || WorkspaceResponseSchema;
+  return schema.safeParse(httpResult.data);
+}
+
+// src/actions/list-instance-types.ts
+var import_zod20 = require("zod");
+var ListInstanceTypesRequestSchema = import_zod20.z.object({
+  page: import_zod20.z.number().int().min(1).optional().default(1),
+  page_size: import_zod20.z.number().int().min(1).max(1e3).optional().default(100)
+}).strict();
+var InstanceTypeSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  name: import_zod20.z.string(),
+  description: import_zod20.z.string(),
+  vcpu: import_zod20.z.number(),
+  memory_mb: import_zod20.z.number(),
+  hourly_rate: import_zod20.z.string(),
+  requires_gpu: import_zod20.z.boolean(),
+  public: import_zod20.z.boolean(),
+  enabled: import_zod20.z.boolean()
+}).passthrough();
+var PaginatedInstanceTypesSchema = import_zod20.z.object({
+  items: import_zod20.z.array(InstanceTypeSchema),
+  total: import_zod20.z.number(),
+  page: import_zod20.z.number(),
+  page_size: import_zod20.z.number(),
+  pages: import_zod20.z.number()
+}).strict();
+async function listInstanceTypes(client, request, parameters) {
+  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
+  validateActionParameters(parameters);
+  const queryParams = new URLSearchParams();
+  queryParams.append("page", validatedRequest.page.toString());
+  queryParams.append("page_size", validatedRequest.page_size.toString());
+  const response = await client.get(`/api/instance-types?${queryParams.toString()}`);
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || PaginatedInstanceTypesSchema;
+  return schema.parse(response);
+}
+async function safeListInstanceTypes(client, request, parameters) {
+  const requestValidation = ListInstanceTypesRequestSchema.safeParse(request ?? {});
+  if (!requestValidation.success) {
+    return requestValidation;
+  }
+  const parameterValidationError = safeValidateActionParameters(parameters);
+  if (parameterValidationError) {
+    return parameterValidationError;
+  }
+  const queryParams = new URLSearchParams();
+  queryParams.append("page", requestValidation.data.page.toString());
+  queryParams.append("page_size", requestValidation.data.page_size.toString());
+  const httpResult = await client.safeGet(`/api/instance-types?${queryParams.toString()}`);
+  if (!httpResult.success) {
+    return httpResult;
+  }
+  if (parameters?.schema === false) {
+    return {
+      success: true,
+      data: httpResult.data
+    };
+  }
+  const schema = parameters?.schema || PaginatedInstanceTypesSchema;
+  const validationResult = schema.safeParse(httpResult.data);
+  return validationResult;
+}
+
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -2535,12 +2703,15 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
   GetAppEnvEncryptPubKeySchema,
-  GetCvmComposeFileResultSchema,
   GetCvmListSchema,
   GetKmsListSchema,
+  InstanceTypeSchema,
   KmsInfoSchema,
+  ListWorkspacesSchema,
   ManagedUserSchema,
   NetworkError,
+  PaginatedInstanceTypesSchema,
+  PaginationMetadataSchema,
   ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema,
@@ -2550,6 +2721,7 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   TransactionError,
   VmInfoSchema,
   WalletError,
+  WorkspaceResponseSchema,
   addComposeHash,
   addNetwork,
   asHex,
@@ -2580,6 +2752,9 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   getErrorMessage,
   getKmsInfo,
   getKmsList,
+  getWorkspace,
+  listInstanceTypes,
+  listWorkspaces,
   parseEnv,
   parseEnvVars,
   provisionCvm,
@@ -2596,6 +2771,9 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   safeGetCvmList,
   safeGetKmsInfo,
   safeGetKmsList,
+  safeGetWorkspace,
+  safeListInstanceTypes,
+  safeListWorkspaces,
   safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate,
   safeValidateActionParameters,