@meetkai/mka1 0.51.39 → 0.53.0

package/src/models/components/computeservice.ts

@@ -48,6 +48,12 @@ import {
   ComputeSSH$Outbound,
   ComputeSSH$outboundSchema,
 } from "./computessh.js";
+import {
+  ComputeVolume,
+  ComputeVolume$inboundSchema,
+  ComputeVolume$Outbound,
+  ComputeVolume$outboundSchema,
+} from "./computevolume.js";
 
 export type ComputeService = {
   accruedUsd: number;
@@ -70,6 +76,7 @@ export type ComputeService = {
   state: ComputeResourceState;
   terminalAt: Date | null;
   ready: boolean;
+  volume?: ComputeVolume | undefined;
 };
 
 /** @internal */
@@ -101,6 +108,7 @@ export const ComputeService$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
   ready: z.boolean(),
+  volume: ComputeVolume$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "accrued_usd": "accruedUsd",
@@ -130,6 +138,7 @@ export type ComputeService$Outbound = {
   state: string;
   terminal_at: string | null;
   ready: boolean;
+  volume?: ComputeVolume$Outbound | undefined;
 };
 
 /** @internal */
@@ -155,6 +164,7 @@ export const ComputeService$outboundSchema: z.ZodType<
   state: ComputeResourceState$outboundSchema,
   terminalAt: z.nullable(z.date().transform(v => v.toISOString())),
   ready: z.boolean(),
+  volume: ComputeVolume$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     accruedUsd: "accrued_usd",

package/src/models/components/computeserviceinput.ts

@@ -12,9 +12,16 @@ import {
   ComputeReadiness$Outbound,
   ComputeReadiness$outboundSchema,
 } from "./computereadiness.js";
+import {
+  ComputeVolumeInput,
+  ComputeVolumeInput$inboundSchema,
+  ComputeVolumeInput$Outbound,
+  ComputeVolumeInput$outboundSchema,
+} from "./computevolumeinput.js";
 
 export type ComputeServiceInput = {
   readiness?: ComputeReadiness | undefined;
+  volume?: ComputeVolumeInput | undefined;
 };
 
 /** @internal */
@@ -24,10 +31,12 @@ export const ComputeServiceInput$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   readiness: ComputeReadiness$inboundSchema.optional(),
+  volume: ComputeVolumeInput$inboundSchema.optional(),
 });
 /** @internal */
 export type ComputeServiceInput$Outbound = {
   readiness?: ComputeReadiness$Outbound | undefined;
+  volume?: ComputeVolumeInput$Outbound | undefined;
 };
 
 /** @internal */
@@ -37,6 +46,7 @@ export const ComputeServiceInput$outboundSchema: z.ZodType<
   ComputeServiceInput
 > = z.object({
   readiness: ComputeReadiness$outboundSchema.optional(),
+  volume: ComputeVolumeInput$outboundSchema.optional(),
 });
 
 export function computeServiceInputToJSON(

package/src/models/components/computeusage.ts

@@ -13,9 +13,15 @@ import {
   ComputeResourceType$outboundSchema,
 } from "./computeresourcetype.js";
 
+export type CostBreakdownUsd = {
+  compute: number;
+  volume: number;
+};
+
 export type ComputeUsageData = {
   accruedUsd: number;
   billableSeconds: number;
+  costBreakdownUsd?: CostBreakdownUsd | undefined;
   name: string;
   resourceId: string;
   resourceType: ComputeResourceType;
@@ -40,6 +46,48 @@ export type ComputeUsage = {
   window: Window;
 };
 
+/** @internal */
+export const CostBreakdownUsd$inboundSchema: z.ZodType<
+  CostBreakdownUsd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  compute: z.number(),
+  volume: z.number(),
+});
+/** @internal */
+export type CostBreakdownUsd$Outbound = {
+  compute: number;
+  volume: number;
+};
+
+/** @internal */
+export const CostBreakdownUsd$outboundSchema: z.ZodType<
+  CostBreakdownUsd$Outbound,
+  z.ZodTypeDef,
+  CostBreakdownUsd
+> = z.object({
+  compute: z.number(),
+  volume: z.number(),
+});
+
+export function costBreakdownUsdToJSON(
+  costBreakdownUsd: CostBreakdownUsd,
+): string {
+  return JSON.stringify(
+    CostBreakdownUsd$outboundSchema.parse(costBreakdownUsd),
+  );
+}
+export function costBreakdownUsdFromJSON(
+  jsonString: string,
+): SafeParseResult<CostBreakdownUsd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CostBreakdownUsd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CostBreakdownUsd' from JSON`,
+  );
+}
+
 /** @internal */
 export const ComputeUsageData$inboundSchema: z.ZodType<
   ComputeUsageData,
@@ -48,6 +96,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
 > = z.object({
   accrued_usd: z.number(),
   billable_seconds: z.number().int(),
+  cost_breakdown_usd: z.lazy(() => CostBreakdownUsd$inboundSchema).optional(),
   name: z.string(),
   resource_id: z.string(),
   resource_type: ComputeResourceType$inboundSchema,
@@ -55,6 +104,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
   return remap$(v, {
     "accrued_usd": "accruedUsd",
     "billable_seconds": "billableSeconds",
+    "cost_breakdown_usd": "costBreakdownUsd",
     "resource_id": "resourceId",
     "resource_type": "resourceType",
   });
@@ -63,6 +113,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
 export type ComputeUsageData$Outbound = {
   accrued_usd: number;
   billable_seconds: number;
+  cost_breakdown_usd?: CostBreakdownUsd$Outbound | undefined;
   name: string;
   resource_id: string;
   resource_type: string;
@@ -76,6 +127,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
 > = z.object({
   accruedUsd: z.number(),
   billableSeconds: z.number().int(),
+  costBreakdownUsd: z.lazy(() => CostBreakdownUsd$outboundSchema).optional(),
   name: z.string(),
   resourceId: z.string(),
   resourceType: ComputeResourceType$outboundSchema,
@@ -83,6 +135,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
   return remap$(v, {
     accruedUsd: "accrued_usd",
     billableSeconds: "billable_seconds",
+    costBreakdownUsd: "cost_breakdown_usd",
     resourceId: "resource_id",
     resourceType: "resource_type",
   });

package/src/models/components/computevolume.ts

@@ -0,0 +1,108 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ComputeVolumeData,
+  ComputeVolumeData$inboundSchema,
+  ComputeVolumeData$Outbound,
+  ComputeVolumeData$outboundSchema,
+} from "./computevolumedata.js";
+
+export const ComputeVolumeStatus = {
+  Provisioning: "provisioning",
+  Loading: "loading",
+  Ready: "ready",
+  Deleting: "deleting",
+  Deleted: "deleted",
+  Failed: "failed",
+} as const;
+export type ComputeVolumeStatus = ClosedEnum<typeof ComputeVolumeStatus>;
+
+export type ComputeVolume = {
+  accruedCostUsd: number;
+  data: Array<ComputeVolumeData>;
+  mountPath: string;
+  priceUsdHr: number;
+  sizeGb: number;
+  status: ComputeVolumeStatus;
+};
+
+/** @internal */
+export const ComputeVolumeStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeStatus
+> = z.nativeEnum(ComputeVolumeStatus);
+/** @internal */
+export const ComputeVolumeStatus$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeStatus
+> = ComputeVolumeStatus$inboundSchema;
+
+/** @internal */
+export const ComputeVolume$inboundSchema: z.ZodType<
+  ComputeVolume,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accrued_cost_usd: z.number(),
+  data: z.array(ComputeVolumeData$inboundSchema),
+  mount_path: z.string(),
+  price_usd_hr: z.number(),
+  size_gb: z.number().int(),
+  status: ComputeVolumeStatus$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "accrued_cost_usd": "accruedCostUsd",
+    "mount_path": "mountPath",
+    "price_usd_hr": "priceUsdHr",
+    "size_gb": "sizeGb",
+  });
+});
+/** @internal */
+export type ComputeVolume$Outbound = {
+  accrued_cost_usd: number;
+  data: Array<ComputeVolumeData$Outbound>;
+  mount_path: string;
+  price_usd_hr: number;
+  size_gb: number;
+  status: string;
+};
+
+/** @internal */
+export const ComputeVolume$outboundSchema: z.ZodType<
+  ComputeVolume$Outbound,
+  z.ZodTypeDef,
+  ComputeVolume
+> = z.object({
+  accruedCostUsd: z.number(),
+  data: z.array(ComputeVolumeData$outboundSchema),
+  mountPath: z.string(),
+  priceUsdHr: z.number(),
+  sizeGb: z.number().int(),
+  status: ComputeVolumeStatus$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    accruedCostUsd: "accrued_cost_usd",
+    mountPath: "mount_path",
+    priceUsdHr: "price_usd_hr",
+    sizeGb: "size_gb",
+  });
+});
+
+export function computeVolumeToJSON(computeVolume: ComputeVolume): string {
+  return JSON.stringify(ComputeVolume$outboundSchema.parse(computeVolume));
+}
+export function computeVolumeFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeVolume, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeVolume$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeVolume' from JSON`,
+  );
+}

package/src/models/components/computevolumedata.ts

@@ -0,0 +1,92 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ComputeVolumeDataType = {
+  Huggingface: "huggingface",
+  Git: "git",
+} as const;
+export type ComputeVolumeDataType = ClosedEnum<typeof ComputeVolumeDataType>;
+
+export type ComputeVolumeData = {
+  path: string;
+  resolvedRevision: string | null;
+  revision: string | null;
+  type: ComputeVolumeDataType;
+  url: string;
+};
+
+/** @internal */
+export const ComputeVolumeDataType$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeDataType
+> = z.nativeEnum(ComputeVolumeDataType);
+/** @internal */
+export const ComputeVolumeDataType$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeDataType
+> = ComputeVolumeDataType$inboundSchema;
+
+/** @internal */
+export const ComputeVolumeData$inboundSchema: z.ZodType<
+  ComputeVolumeData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  path: z.string(),
+  resolved_revision: z.nullable(z.string()),
+  revision: z.nullable(z.string()),
+  type: ComputeVolumeDataType$inboundSchema,
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "resolved_revision": "resolvedRevision",
+  });
+});
+/** @internal */
+export type ComputeVolumeData$Outbound = {
+  path: string;
+  resolved_revision: string | null;
+  revision: string | null;
+  type: string;
+  url: string;
+};
+
+/** @internal */
+export const ComputeVolumeData$outboundSchema: z.ZodType<
+  ComputeVolumeData$Outbound,
+  z.ZodTypeDef,
+  ComputeVolumeData
+> = z.object({
+  path: z.string(),
+  resolvedRevision: z.nullable(z.string()),
+  revision: z.nullable(z.string()),
+  type: ComputeVolumeDataType$outboundSchema,
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    resolvedRevision: "resolved_revision",
+  });
+});
+
+export function computeVolumeDataToJSON(
+  computeVolumeData: ComputeVolumeData,
+): string {
+  return JSON.stringify(
+    ComputeVolumeData$outboundSchema.parse(computeVolumeData),
+  );
+}
+export function computeVolumeDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeVolumeData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeVolumeData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeVolumeData' from JSON`,
+  );
+}

package/src/models/components/computevolumedatainput.ts

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ComputeVolumeDataInputType = {
+  Huggingface: "huggingface",
+  Git: "git",
+} as const;
+export type ComputeVolumeDataInputType = ClosedEnum<
+  typeof ComputeVolumeDataInputType
+>;
+
+export type ComputeVolumeDataInput = {
+  path: string;
+  revision?: string | undefined;
+  type: ComputeVolumeDataInputType;
+  url: string;
+};
+
+/** @internal */
+export const ComputeVolumeDataInputType$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeDataInputType
+> = z.nativeEnum(ComputeVolumeDataInputType);
+/** @internal */
+export const ComputeVolumeDataInputType$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeVolumeDataInputType
+> = ComputeVolumeDataInputType$inboundSchema;
+
+/** @internal */
+export const ComputeVolumeDataInput$inboundSchema: z.ZodType<
+  ComputeVolumeDataInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  path: z.string(),
+  revision: z.string().optional(),
+  type: ComputeVolumeDataInputType$inboundSchema,
+  url: z.string(),
+});
+/** @internal */
+export type ComputeVolumeDataInput$Outbound = {
+  path: string;
+  revision?: string | undefined;
+  type: string;
+  url: string;
+};
+
+/** @internal */
+export const ComputeVolumeDataInput$outboundSchema: z.ZodType<
+  ComputeVolumeDataInput$Outbound,
+  z.ZodTypeDef,
+  ComputeVolumeDataInput
+> = z.object({
+  path: z.string(),
+  revision: z.string().optional(),
+  type: ComputeVolumeDataInputType$outboundSchema,
+  url: z.string(),
+});
+
+export function computeVolumeDataInputToJSON(
+  computeVolumeDataInput: ComputeVolumeDataInput,
+): string {
+  return JSON.stringify(
+    ComputeVolumeDataInput$outboundSchema.parse(computeVolumeDataInput),
+  );
+}
+export function computeVolumeDataInputFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeVolumeDataInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeVolumeDataInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeVolumeDataInput' from JSON`,
+  );
+}

package/src/models/components/computevolumeinput.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 {
+  ComputeVolumeDataInput,
+  ComputeVolumeDataInput$inboundSchema,
+  ComputeVolumeDataInput$Outbound,
+  ComputeVolumeDataInput$outboundSchema,
+} from "./computevolumedatainput.js";
+
+export type ComputeVolumeInput = {
+  data?: Array<ComputeVolumeDataInput> | undefined;
+  mountPath: string;
+  sizeGb: number;
+};
+
+/** @internal */
+export const ComputeVolumeInput$inboundSchema: z.ZodType<
+  ComputeVolumeInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(ComputeVolumeDataInput$inboundSchema).optional(),
+  mount_path: z.string(),
+  size_gb: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "mount_path": "mountPath",
+    "size_gb": "sizeGb",
+  });
+});
+/** @internal */
+export type ComputeVolumeInput$Outbound = {
+  data?: Array<ComputeVolumeDataInput$Outbound> | undefined;
+  mount_path: string;
+  size_gb: number;
+};
+
+/** @internal */
+export const ComputeVolumeInput$outboundSchema: z.ZodType<
+  ComputeVolumeInput$Outbound,
+  z.ZodTypeDef,
+  ComputeVolumeInput
+> = z.object({
+  data: z.array(ComputeVolumeDataInput$outboundSchema).optional(),
+  mountPath: z.string(),
+  sizeGb: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    mountPath: "mount_path",
+    sizeGb: "size_gb",
+  });
+});
+
+export function computeVolumeInputToJSON(
+  computeVolumeInput: ComputeVolumeInput,
+): string {
+  return JSON.stringify(
+    ComputeVolumeInput$outboundSchema.parse(computeVolumeInput),
+  );
+}
+export function computeVolumeInputFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeVolumeInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeVolumeInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeVolumeInput' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -124,6 +124,10 @@ export * from "./computetenant.js";
 export * from "./computetenantlist.js";
 export * from "./computetenantupdate.js";
 export * from "./computeusage.js";
+export * from "./computevolume.js";
+export * from "./computevolumedata.js";
+export * from "./computevolumedatainput.js";
+export * from "./computevolumeinput.js";
 export * from "./containerfilecitation.js";
 export * from "./conversation.js";
 export * from "./conversationdeletedobject.js";