@meetkai/mka1 0.54.6 → 0.54.8

package/src/models/components/codeinterpreteroutput.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -21,17 +23,18 @@ import {
 
 export type CodeInterpreterOutput =
   | CodeInterpreterOutputLogs
-  | CodeInterpreterOutputImage;
+  | CodeInterpreterOutputImage
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const CodeInterpreterOutput$inboundSchema: z.ZodType<
   CodeInterpreterOutput,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  CodeInterpreterOutputLogs$inboundSchema,
-  CodeInterpreterOutputImage$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  logs: CodeInterpreterOutputLogs$inboundSchema,
+  image: CodeInterpreterOutputImage$inboundSchema,
+});
 /** @internal */
 export type CodeInterpreterOutput$Outbound =
   | CodeInterpreterOutputLogs$Outbound

package/src/models/components/computejob.ts

@@ -48,6 +48,12 @@ import {
   ComputeSSH$Outbound,
   ComputeSSH$outboundSchema,
 } from "./computessh.js";
+import {
+  ComputeStandaloneVolumeMount,
+  ComputeStandaloneVolumeMount$inboundSchema,
+  ComputeStandaloneVolumeMount$Outbound,
+  ComputeStandaloneVolumeMount$outboundSchema,
+} from "./computestandalonevolumemount.js";
 
 export type ComputeJob = {
   accruedUsd: number;
@@ -69,6 +75,7 @@ export type ComputeJob = {
   startedAt: Date | null;
   state: ComputeResourceState;
   terminalAt: Date | null;
+  volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
   exitCode?: number | undefined;
 };
 
@@ -100,6 +107,7 @@ export const ComputeJob$inboundSchema: z.ZodType<
   terminal_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
+  volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
   exit_code: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -130,6 +138,7 @@ export type ComputeJob$Outbound = {
   started_at: string | null;
   state: string;
   terminal_at: string | null;
+  volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
   exit_code?: number | undefined;
 };
 
@@ -155,6 +164,7 @@ export const ComputeJob$outboundSchema: z.ZodType<
   startedAt: z.nullable(z.date().transform(v => v.toISOString())),
   state: ComputeResourceState$outboundSchema,
   terminalAt: z.nullable(z.date().transform(v => v.toISOString())),
+  volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
   exitCode: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/computejobcreate.ts

@@ -36,6 +36,12 @@ import {
   ComputeRequest$Outbound,
   ComputeRequest$outboundSchema,
 } from "./computerequest.js";
+import {
+  ComputeStandaloneVolumeMount,
+  ComputeStandaloneVolumeMount$inboundSchema,
+  ComputeStandaloneVolumeMount$Outbound,
+  ComputeStandaloneVolumeMount$outboundSchema,
+} from "./computestandalonevolumemount.js";
 
 /**
  * Create body for a job. Jobs accept the same fields as services except the service block.
@@ -47,6 +53,7 @@ export type ComputeJobCreate = {
   limits?: ComputeLimits | undefined;
   name?: string | undefined;
   placement?: ComputePlacement | undefined;
+  volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
 };
 
 /** @internal */
@@ -61,6 +68,7 @@ export const ComputeJobCreate$inboundSchema: z.ZodType<
   limits: ComputeLimits$inboundSchema.optional(),
   name: z.string().optional(),
   placement: ComputePlacement$inboundSchema.optional(),
+  volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
 });
 /** @internal */
 export type ComputeJobCreate$Outbound = {
@@ -70,6 +78,7 @@ export type ComputeJobCreate$Outbound = {
   limits?: ComputeLimits$Outbound | undefined;
   name?: string | undefined;
   placement?: ComputePlacement$Outbound | undefined;
+  volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
 };
 
 /** @internal */
@@ -84,6 +93,7 @@ export const ComputeJobCreate$outboundSchema: z.ZodType<
   limits: ComputeLimits$outboundSchema.optional(),
   name: z.string().optional(),
   placement: ComputePlacement$outboundSchema.optional(),
+  volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
 });
 
 export function computeJobCreateToJSON(

package/src/models/components/computeoffer.ts

@@ -17,6 +17,7 @@ export type ComputeOfferCapabilities = {
   scaleToZero: boolean;
   sharedVolume: boolean;
   ssh: boolean;
+  standaloneVolume: boolean;
   tcpPorts: boolean;
 };
 
@@ -65,6 +66,7 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
   scale_to_zero: z.boolean(),
   shared_volume: z.boolean(),
   ssh: z.boolean(),
+  standalone_volume: z.boolean(),
   tcp_ports: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
@@ -75,6 +77,7 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
     "persistent_volume": "persistentVolume",
     "scale_to_zero": "scaleToZero",
     "shared_volume": "sharedVolume",
+    "standalone_volume": "standaloneVolume",
     "tcp_ports": "tcpPorts",
   });
 });
@@ -88,6 +91,7 @@ export type ComputeOfferCapabilities$Outbound = {
   scale_to_zero: boolean;
   shared_volume: boolean;
   ssh: boolean;
+  standalone_volume: boolean;
   tcp_ports: boolean;
 };
 
@@ -105,6 +109,7 @@ export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
   scaleToZero: z.boolean(),
   sharedVolume: z.boolean(),
   ssh: z.boolean(),
+  standaloneVolume: z.boolean(),
   tcpPorts: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
@@ -115,6 +120,7 @@ export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
     persistentVolume: "persistent_volume",
     scaleToZero: "scale_to_zero",
     sharedVolume: "shared_volume",
+    standaloneVolume: "standalone_volume",
     tcpPorts: "tcp_ports",
   });
 });

package/src/models/components/computepricing.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ComputePricing = {
+  effectiveAt: Date;
+  version: number;
+  /**
+   * Exact USD-per-GiB-hour decimal from 0.000000000000000001 through 10000000000 inclusive, in increments of 0.000000000000000001, with at most 38 mantissa digits, 64 JSON-number characters, and exponent magnitude 128. This range is representable by the numeric(38,18) hourly ledger across the supported int64 stored-byte domain.
+   */
+  volumeStorageUsdPerGibHour: number;
+};
+
+/** @internal */
+export const ComputePricing$inboundSchema: z.ZodType<
+  ComputePricing,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  effective_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  version: z.number().int(),
+  volume_storage_usd_per_gib_hour: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "effective_at": "effectiveAt",
+    "volume_storage_usd_per_gib_hour": "volumeStorageUsdPerGibHour",
+  });
+});
+/** @internal */
+export type ComputePricing$Outbound = {
+  effective_at: string;
+  version: number;
+  volume_storage_usd_per_gib_hour: number;
+};
+
+/** @internal */
+export const ComputePricing$outboundSchema: z.ZodType<
+  ComputePricing$Outbound,
+  z.ZodTypeDef,
+  ComputePricing
+> = z.object({
+  effectiveAt: z.date().transform(v => v.toISOString()),
+  version: z.number().int(),
+  volumeStorageUsdPerGibHour: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    effectiveAt: "effective_at",
+    volumeStorageUsdPerGibHour: "volume_storage_usd_per_gib_hour",
+  });
+});
+
+export function computePricingToJSON(computePricing: ComputePricing): string {
+  return JSON.stringify(ComputePricing$outboundSchema.parse(computePricing));
+}
+export function computePricingFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputePricing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputePricing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputePricing' from JSON`,
+  );
+}

package/src/models/components/computepricingupdate.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ComputePricingUpdate = {
+  /**
+   * Exact USD-per-GiB-hour decimal from 0.000000000000000001 through 10000000000 inclusive, in increments of 0.000000000000000001, with at most 38 mantissa digits, 64 JSON-number characters, and exponent magnitude 128. This range is representable by the numeric(38,18) hourly ledger across the supported int64 stored-byte domain.
+   */
+  volumeStorageUsdPerGibHour: number;
+};
+
+/** @internal */
+export const ComputePricingUpdate$inboundSchema: z.ZodType<
+  ComputePricingUpdate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  volume_storage_usd_per_gib_hour: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "volume_storage_usd_per_gib_hour": "volumeStorageUsdPerGibHour",
+  });
+});
+/** @internal */
+export type ComputePricingUpdate$Outbound = {
+  volume_storage_usd_per_gib_hour: number;
+};
+
+/** @internal */
+export const ComputePricingUpdate$outboundSchema: z.ZodType<
+  ComputePricingUpdate$Outbound,
+  z.ZodTypeDef,
+  ComputePricingUpdate
+> = z.object({
+  volumeStorageUsdPerGibHour: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    volumeStorageUsdPerGibHour: "volume_storage_usd_per_gib_hour",
+  });
+});
+
+export function computePricingUpdateToJSON(
+  computePricingUpdate: ComputePricingUpdate,
+): string {
+  return JSON.stringify(
+    ComputePricingUpdate$outboundSchema.parse(computePricingUpdate),
+  );
+}
+export function computePricingUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputePricingUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputePricingUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputePricingUpdate' from JSON`,
+  );
+}

package/src/models/components/computeraction.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -70,24 +72,25 @@ export type ComputerAction =
   | ScreenshotAction
   | ScrollAction
   | TypeAction
-  | WaitAction;
+  | WaitAction
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const ComputerAction$inboundSchema: z.ZodType<
   ComputerAction,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  ClickAction$inboundSchema,
-  DoubleClickAction$inboundSchema,
-  DragAction$inboundSchema,
-  KeyPressAction$inboundSchema,
-  MoveAction$inboundSchema,
-  ScreenshotAction$inboundSchema,
-  ScrollAction$inboundSchema,
-  TypeAction$inboundSchema,
-  WaitAction$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  click: ClickAction$inboundSchema,
+  double_click: DoubleClickAction$inboundSchema,
+  drag: DragAction$inboundSchema,
+  keypress: KeyPressAction$inboundSchema,
+  move: MoveAction$inboundSchema,
+  screenshot: ScreenshotAction$inboundSchema,
+  scroll: ScrollAction$inboundSchema,
+  type: TypeAction$inboundSchema,
+  wait: WaitAction$inboundSchema,
+});
 /** @internal */
 export type ComputerAction$Outbound =
   | ClickAction$Outbound

package/src/models/components/computeresourcecreate.ts

@@ -42,6 +42,12 @@ import {
   ComputeServiceInput$Outbound,
   ComputeServiceInput$outboundSchema,
 } from "./computeserviceinput.js";
+import {
+  ComputeStandaloneVolumeMount,
+  ComputeStandaloneVolumeMount$inboundSchema,
+  ComputeStandaloneVolumeMount$Outbound,
+  ComputeStandaloneVolumeMount$outboundSchema,
+} from "./computestandalonevolumemount.js";
 
 export type ComputeResourceCreate = {
   access?: ComputeAccessCreate | undefined;
@@ -51,6 +57,7 @@ export type ComputeResourceCreate = {
   name?: string | undefined;
   placement?: ComputePlacement | undefined;
   service?: ComputeServiceInput | undefined;
+  volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
 };
 
 /** @internal */
@@ -66,6 +73,7 @@ export const ComputeResourceCreate$inboundSchema: z.ZodType<
   name: z.string().optional(),
   placement: ComputePlacement$inboundSchema.optional(),
   service: ComputeServiceInput$inboundSchema.optional(),
+  volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
 });
 /** @internal */
 export type ComputeResourceCreate$Outbound = {
@@ -76,6 +84,7 @@ export type ComputeResourceCreate$Outbound = {
   name?: string | undefined;
   placement?: ComputePlacement$Outbound | undefined;
   service?: ComputeServiceInput$Outbound | undefined;
+  volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
 };
 
 /** @internal */
@@ -91,6 +100,7 @@ export const ComputeResourceCreate$outboundSchema: z.ZodType<
   name: z.string().optional(),
   placement: ComputePlacement$outboundSchema.optional(),
   service: ComputeServiceInput$outboundSchema.optional(),
+  volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
 });
 
 export function computeResourceCreateToJSON(

package/src/models/components/computeservice.ts

@@ -48,6 +48,12 @@ import {
   ComputeSSH$Outbound,
   ComputeSSH$outboundSchema,
 } from "./computessh.js";
+import {
+  ComputeStandaloneVolumeMount,
+  ComputeStandaloneVolumeMount$inboundSchema,
+  ComputeStandaloneVolumeMount$Outbound,
+  ComputeStandaloneVolumeMount$outboundSchema,
+} from "./computestandalonevolumemount.js";
 import {
   ComputeVolume,
   ComputeVolume$inboundSchema,
@@ -75,6 +81,7 @@ export type ComputeService = {
   startedAt: Date | null;
   state: ComputeResourceState;
   terminalAt: Date | null;
+  volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
   ready: boolean;
   volume?: ComputeVolume | undefined;
 };
@@ -107,6 +114,7 @@ export const ComputeService$inboundSchema: z.ZodType<
   terminal_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
+  volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
   ready: z.boolean(),
   volume: ComputeVolume$inboundSchema.optional(),
 }).transform((v) => {
@@ -137,6 +145,7 @@ export type ComputeService$Outbound = {
   started_at: string | null;
   state: string;
   terminal_at: string | null;
+  volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
   ready: boolean;
   volume?: ComputeVolume$Outbound | undefined;
 };
@@ -163,6 +172,7 @@ export const ComputeService$outboundSchema: z.ZodType<
   startedAt: z.nullable(z.date().transform(v => v.toISOString())),
   state: ComputeResourceState$outboundSchema,
   terminalAt: z.nullable(z.date().transform(v => v.toISOString())),
+  volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
   ready: z.boolean(),
   volume: ComputeVolume$outboundSchema.optional(),
 }).transform((v) => {

package/src/models/components/computestandalonevolume.ts

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ComputeReason,
+  ComputeReason$inboundSchema,
+  ComputeReason$Outbound,
+  ComputeReason$outboundSchema,
+} from "./computereason.js";
+import {
+  ComputeStandaloneVolumeState,
+  ComputeStandaloneVolumeState$inboundSchema,
+  ComputeStandaloneVolumeState$outboundSchema,
+} from "./computestandalonevolumestate.js";
+
+export type ComputeStandaloneVolume = {
+  accruedCostUsd: number;
+  attachmentCount: number;
+  cleanupFailure: ComputeReason | null;
+  createdAt: Date;
+  currentStoragePriceUsdHr: number;
+  deletedAt: Date | null;
+  failure: ComputeReason | null;
+  id: string;
+  name: string;
+  provisionedAt: Date | null;
+  status: ComputeStandaloneVolumeState;
+  storageRateUsdPerGibHour: number;
+  storedBytes: number;
+  storedBytesObservedAt: Date | null;
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ComputeStandaloneVolume$inboundSchema: z.ZodType<
+  ComputeStandaloneVolume,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accrued_cost_usd: z.number(),
+  attachment_count: z.number().int(),
+  cleanup_failure: z.nullable(ComputeReason$inboundSchema),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  current_storage_price_usd_hr: z.number(),
+  deleted_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  failure: z.nullable(ComputeReason$inboundSchema),
+  id: z.string(),
+  name: z.string(),
+  provisioned_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  status: ComputeStandaloneVolumeState$inboundSchema,
+  storage_rate_usd_per_gib_hour: z.number(),
+  stored_bytes: z.number().int(),
+  stored_bytes_observed_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "accrued_cost_usd": "accruedCostUsd",
+    "attachment_count": "attachmentCount",
+    "cleanup_failure": "cleanupFailure",
+    "created_at": "createdAt",
+    "current_storage_price_usd_hr": "currentStoragePriceUsdHr",
+    "deleted_at": "deletedAt",
+    "provisioned_at": "provisionedAt",
+    "storage_rate_usd_per_gib_hour": "storageRateUsdPerGibHour",
+    "stored_bytes": "storedBytes",
+    "stored_bytes_observed_at": "storedBytesObservedAt",
+    "updated_at": "updatedAt",
+  });
+});
+/** @internal */
+export type ComputeStandaloneVolume$Outbound = {
+  accrued_cost_usd: number;
+  attachment_count: number;
+  cleanup_failure: ComputeReason$Outbound | null;
+  created_at: string;
+  current_storage_price_usd_hr: number;
+  deleted_at: string | null;
+  failure: ComputeReason$Outbound | null;
+  id: string;
+  name: string;
+  provisioned_at: string | null;
+  status: string;
+  storage_rate_usd_per_gib_hour: number;
+  stored_bytes: number;
+  stored_bytes_observed_at: string | null;
+  updated_at: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolume$outboundSchema: z.ZodType<
+  ComputeStandaloneVolume$Outbound,
+  z.ZodTypeDef,
+  ComputeStandaloneVolume
+> = z.object({
+  accruedCostUsd: z.number(),
+  attachmentCount: z.number().int(),
+  cleanupFailure: z.nullable(ComputeReason$outboundSchema),
+  createdAt: z.date().transform(v => v.toISOString()),
+  currentStoragePriceUsdHr: z.number(),
+  deletedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  failure: z.nullable(ComputeReason$outboundSchema),
+  id: z.string(),
+  name: z.string(),
+  provisionedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  status: ComputeStandaloneVolumeState$outboundSchema,
+  storageRateUsdPerGibHour: z.number(),
+  storedBytes: z.number().int(),
+  storedBytesObservedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  updatedAt: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    accruedCostUsd: "accrued_cost_usd",
+    attachmentCount: "attachment_count",
+    cleanupFailure: "cleanup_failure",
+    createdAt: "created_at",
+    currentStoragePriceUsdHr: "current_storage_price_usd_hr",
+    deletedAt: "deleted_at",
+    provisionedAt: "provisioned_at",
+    storageRateUsdPerGibHour: "storage_rate_usd_per_gib_hour",
+    storedBytes: "stored_bytes",
+    storedBytesObservedAt: "stored_bytes_observed_at",
+    updatedAt: "updated_at",
+  });
+});
+
+export function computeStandaloneVolumeToJSON(
+  computeStandaloneVolume: ComputeStandaloneVolume,
+): string {
+  return JSON.stringify(
+    ComputeStandaloneVolume$outboundSchema.parse(computeStandaloneVolume),
+  );
+}
+export function computeStandaloneVolumeFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeStandaloneVolume, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeStandaloneVolume$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeStandaloneVolume' from JSON`,
+  );
+}