@meetkai/mka1 0.54.6 → 0.54.8

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

package/src/models/components/computestandalonevolumelist.ts

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

package/src/models/components/computestandalonevolumemount.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 ComputeStandaloneVolumeMount = {
+  mountPath: string;
+  volumeId: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeMount$inboundSchema: z.ZodType<
+  ComputeStandaloneVolumeMount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mount_path: z.string(),
+  volume_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "mount_path": "mountPath",
+    "volume_id": "volumeId",
+  });
+});
+/** @internal */
+export type ComputeStandaloneVolumeMount$Outbound = {
+  mount_path: string;
+  volume_id: string;
+};
+
+/** @internal */
+export const ComputeStandaloneVolumeMount$outboundSchema: z.ZodType<
+  ComputeStandaloneVolumeMount$Outbound,
+  z.ZodTypeDef,
+  ComputeStandaloneVolumeMount
+> = z.object({
+  mountPath: z.string(),
+  volumeId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    mountPath: "mount_path",
+    volumeId: "volume_id",
+  });
+});
+
+export function computeStandaloneVolumeMountToJSON(
+  computeStandaloneVolumeMount: ComputeStandaloneVolumeMount,
+): string {
+  return JSON.stringify(
+    ComputeStandaloneVolumeMount$outboundSchema.parse(
+      computeStandaloneVolumeMount,
+    ),
+  );
+}
+export function computeStandaloneVolumeMountFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeStandaloneVolumeMount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeStandaloneVolumeMount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeStandaloneVolumeMount' from JSON`,
+  );
+}

package/src/models/components/computestandalonevolumestate.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ComputeStandaloneVolumeState = {
+  Creating: "creating",
+  Ready: "ready",
+  Deleting: "deleting",
+  Deleted: "deleted",
+  Failed: "failed",
+} as const;
+export type ComputeStandaloneVolumeState = ClosedEnum<
+  typeof ComputeStandaloneVolumeState
+>;
+
+/** @internal */
+export const ComputeStandaloneVolumeState$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeStandaloneVolumeState
+> = z.nativeEnum(ComputeStandaloneVolumeState);
+/** @internal */
+export const ComputeStandaloneVolumeState$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeStandaloneVolumeState
+> = ComputeStandaloneVolumeState$inboundSchema;

package/src/models/components/computetenant.ts

@@ -13,6 +13,7 @@ export type ComputeTenant = {
   enabled: boolean;
   maxLiveJobs: number | null;
   maxLiveServices: number | null;
+  maxLiveVolumes: number | null;
   orgId: string;
   updatedAt: Date;
 };
@@ -27,6 +28,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
   enabled: z.boolean(),
   max_live_jobs: z.nullable(z.number().int()),
   max_live_services: z.nullable(z.number().int()),
+  max_live_volumes: z.nullable(z.number().int()),
   org_id: z.string(),
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 }).transform((v) => {
@@ -34,6 +36,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
     "created_at": "createdAt",
     "max_live_jobs": "maxLiveJobs",
     "max_live_services": "maxLiveServices",
+    "max_live_volumes": "maxLiveVolumes",
     "org_id": "orgId",
     "updated_at": "updatedAt",
   });
@@ -44,6 +47,7 @@ export type ComputeTenant$Outbound = {
   enabled: boolean;
   max_live_jobs: number | null;
   max_live_services: number | null;
+  max_live_volumes: number | null;
   org_id: string;
   updated_at: string;
 };
@@ -58,6 +62,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
   enabled: z.boolean(),
   maxLiveJobs: z.nullable(z.number().int()),
   maxLiveServices: z.nullable(z.number().int()),
+  maxLiveVolumes: z.nullable(z.number().int()),
   orgId: z.string(),
   updatedAt: z.date().transform(v => v.toISOString()),
 }).transform((v) => {
@@ -65,6 +70,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
     createdAt: "created_at",
     maxLiveJobs: "max_live_jobs",
     maxLiveServices: "max_live_services",
+    maxLiveVolumes: "max_live_volumes",
     orgId: "org_id",
     updatedAt: "updated_at",
   });

package/src/models/components/computetenantupdate.ts

@@ -12,6 +12,7 @@ export type ComputeTenantUpdate = {
   enabled?: boolean | undefined;
   maxLiveJobs?: number | null | undefined;
   maxLiveServices?: number | null | undefined;
+  maxLiveVolumes?: number | null | undefined;
 };
 
 /** @internal */
@@ -23,10 +24,12 @@ export const ComputeTenantUpdate$inboundSchema: z.ZodType<
   enabled: z.boolean().optional(),
   max_live_jobs: z.nullable(z.number().int()).optional(),
   max_live_services: z.nullable(z.number().int()).optional(),
+  max_live_volumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "max_live_jobs": "maxLiveJobs",
     "max_live_services": "maxLiveServices",
+    "max_live_volumes": "maxLiveVolumes",
   });
 });
 /** @internal */
@@ -34,6 +37,7 @@ export type ComputeTenantUpdate$Outbound = {
   enabled?: boolean | undefined;
   max_live_jobs?: number | null | undefined;
   max_live_services?: number | null | undefined;
+  max_live_volumes?: number | null | undefined;
 };
 
 /** @internal */
@@ -45,10 +49,12 @@ export const ComputeTenantUpdate$outboundSchema: z.ZodType<
   enabled: z.boolean().optional(),
   maxLiveJobs: z.nullable(z.number().int()).optional(),
   maxLiveServices: z.nullable(z.number().int()).optional(),
+  maxLiveVolumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     maxLiveJobs: "max_live_jobs",
     maxLiveServices: "max_live_services",
+    maxLiveVolumes: "max_live_volumes",
   });
 });