@meetkai/mka1 0.54.6 → 0.54.7

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/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`,
+  );
+}

package/src/models/components/computestandalonevolumeattachment.ts

@@ -0,0 +1,118 @@
+/*
+ * 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 {
+  ComputeResourceType,
+  ComputeResourceType$inboundSchema,
+  ComputeResourceType$outboundSchema,
+} from "./computeresourcetype.js";
+import {
+  ComputeStandaloneVolumeAttachmentState,
+  ComputeStandaloneVolumeAttachmentState$inboundSchema,
+  ComputeStandaloneVolumeAttachmentState$outboundSchema,
+} from "./computestandalonevolumeattachmentstate.js";
+
+export type ComputeStandaloneVolumeAttachment = {
+  cleanupFailure: ComputeReason | null;
+  createdAt: Date;
+  id: string;
+  mountPath: string;
+  releasedAt: Date | null;
+  resourceId: string;
+  resourceType: ComputeResourceType;
+  status: ComputeStandaloneVolumeAttachmentState;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeAttachment$inboundSchema: z.ZodType<
+  ComputeStandaloneVolumeAttachment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cleanup_failure: z.nullable(ComputeReason$inboundSchema),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  id: z.string(),
+  mount_path: z.string(),
+  released_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  resource_id: z.string(),
+  resource_type: ComputeResourceType$inboundSchema,
+  status: ComputeStandaloneVolumeAttachmentState$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "cleanup_failure": "cleanupFailure",
+    "created_at": "createdAt",
+    "mount_path": "mountPath",
+    "released_at": "releasedAt",
+    "resource_id": "resourceId",
+    "resource_type": "resourceType",
+  });
+});
+/** @internal */
+export type ComputeStandaloneVolumeAttachment$Outbound = {
+  cleanup_failure: ComputeReason$Outbound | null;
+  created_at: string;
+  id: string;
+  mount_path: string;
+  released_at: string | null;
+  resource_id: string;
+  resource_type: string;
+  status: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeAttachment$outboundSchema: z.ZodType<
+  ComputeStandaloneVolumeAttachment$Outbound,
+  z.ZodTypeDef,
+  ComputeStandaloneVolumeAttachment
+> = z.object({
+  cleanupFailure: z.nullable(ComputeReason$outboundSchema),
+  createdAt: z.date().transform(v => v.toISOString()),
+  id: z.string(),
+  mountPath: z.string(),
+  releasedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  resourceId: z.string(),
+  resourceType: ComputeResourceType$outboundSchema,
+  status: ComputeStandaloneVolumeAttachmentState$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    cleanupFailure: "cleanup_failure",
+    createdAt: "created_at",
+    mountPath: "mount_path",
+    releasedAt: "released_at",
+    resourceId: "resource_id",
+    resourceType: "resource_type",
+  });
+});
+
+export function computeStandaloneVolumeAttachmentToJSON(
+  computeStandaloneVolumeAttachment: ComputeStandaloneVolumeAttachment,
+): string {
+  return JSON.stringify(
+    ComputeStandaloneVolumeAttachment$outboundSchema.parse(
+      computeStandaloneVolumeAttachment,
+    ),
+  );
+}
+export function computeStandaloneVolumeAttachmentFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeStandaloneVolumeAttachment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeStandaloneVolumeAttachment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeStandaloneVolumeAttachment' from JSON`,
+  );
+}

package/src/models/components/computestandalonevolumeattachmentlist.ts

@@ -0,0 +1,77 @@
+/*
+ * 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 {
+  ComputeStandaloneVolumeAttachment,
+  ComputeStandaloneVolumeAttachment$inboundSchema,
+  ComputeStandaloneVolumeAttachment$Outbound,
+  ComputeStandaloneVolumeAttachment$outboundSchema,
+} from "./computestandalonevolumeattachment.js";
+
+export type ComputeStandaloneVolumeAttachmentList = {
+  nextCursor: string | null;
+  total: number;
+  data: Array<ComputeStandaloneVolumeAttachment>;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeAttachmentList$inboundSchema: z.ZodType<
+  ComputeStandaloneVolumeAttachmentList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  next_cursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeStandaloneVolumeAttachment$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+  });
+});
+/** @internal */
+export type ComputeStandaloneVolumeAttachmentList$Outbound = {
+  next_cursor: string | null;
+  total: number;
+  data: Array<ComputeStandaloneVolumeAttachment$Outbound>;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeAttachmentList$outboundSchema: z.ZodType<
+  ComputeStandaloneVolumeAttachmentList$Outbound,
+  z.ZodTypeDef,
+  ComputeStandaloneVolumeAttachmentList
+> = z.object({
+  nextCursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeStandaloneVolumeAttachment$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function computeStandaloneVolumeAttachmentListToJSON(
+  computeStandaloneVolumeAttachmentList: ComputeStandaloneVolumeAttachmentList,
+): string {
+  return JSON.stringify(
+    ComputeStandaloneVolumeAttachmentList$outboundSchema.parse(
+      computeStandaloneVolumeAttachmentList,
+    ),
+  );
+}
+export function computeStandaloneVolumeAttachmentListFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeStandaloneVolumeAttachmentList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ComputeStandaloneVolumeAttachmentList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeStandaloneVolumeAttachmentList' from JSON`,
+  );
+}

package/src/models/components/computestandalonevolumeattachmentstate.ts

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ComputeStandaloneVolumeAttachmentState = {
+  Reserved: "reserved",
+  Attaching: "attaching",
+  Attached: "attached",
+  Releasing: "releasing",
+  Released: "released",
+  Failed: "failed",
+} as const;
+export type ComputeStandaloneVolumeAttachmentState = ClosedEnum<
+  typeof ComputeStandaloneVolumeAttachmentState
+>;
+
+/** @internal */
+export const ComputeStandaloneVolumeAttachmentState$inboundSchema:
+  z.ZodNativeEnum<typeof ComputeStandaloneVolumeAttachmentState> = z.nativeEnum(
+    ComputeStandaloneVolumeAttachmentState,
+  );
+/** @internal */
+export const ComputeStandaloneVolumeAttachmentState$outboundSchema:
+  z.ZodNativeEnum<typeof ComputeStandaloneVolumeAttachmentState> =
+    ComputeStandaloneVolumeAttachmentState$inboundSchema;

package/src/models/components/computestandalonevolumecreate.ts

@@ -0,0 +1,53 @@
+/*
+ * 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";
+
+export type ComputeStandaloneVolumeCreate = {
+  name: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeCreate$inboundSchema: z.ZodType<
+  ComputeStandaloneVolumeCreate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+});
+/** @internal */
+export type ComputeStandaloneVolumeCreate$Outbound = {
+  name: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeCreate$outboundSchema: z.ZodType<
+  ComputeStandaloneVolumeCreate$Outbound,
+  z.ZodTypeDef,
+  ComputeStandaloneVolumeCreate
+> = z.object({
+  name: z.string(),
+});
+
+export function computeStandaloneVolumeCreateToJSON(
+  computeStandaloneVolumeCreate: ComputeStandaloneVolumeCreate,
+): string {
+  return JSON.stringify(
+    ComputeStandaloneVolumeCreate$outboundSchema.parse(
+      computeStandaloneVolumeCreate,
+    ),
+  );
+}
+export function computeStandaloneVolumeCreateFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeStandaloneVolumeCreate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeStandaloneVolumeCreate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeStandaloneVolumeCreate' from JSON`,
+  );
+}