@meetkai/mka1 0.51.38 → 0.53.0

package/src/models/components/computequote.ts

@@ -20,14 +20,62 @@ import {
   ComputeProviderQuote$outboundSchema,
 } from "./computeproviderquote.js";
 
+export type PriceBreakdownUsdHr = {
+  compute: ComputePriceRange;
+  volume: ComputePriceRange;
+};
+
 export type ComputeQuote = {
   available: boolean;
   expiresAt: Date | null;
   observedAt: Date;
+  priceBreakdownUsdHr?: PriceBreakdownUsdHr | undefined;
   priceUsdHr: ComputePriceRange | null;
   providers?: Array<ComputeProviderQuote> | undefined;
 };
 
+/** @internal */
+export const PriceBreakdownUsdHr$inboundSchema: z.ZodType<
+  PriceBreakdownUsdHr,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  compute: ComputePriceRange$inboundSchema,
+  volume: ComputePriceRange$inboundSchema,
+});
+/** @internal */
+export type PriceBreakdownUsdHr$Outbound = {
+  compute: ComputePriceRange$Outbound;
+  volume: ComputePriceRange$Outbound;
+};
+
+/** @internal */
+export const PriceBreakdownUsdHr$outboundSchema: z.ZodType<
+  PriceBreakdownUsdHr$Outbound,
+  z.ZodTypeDef,
+  PriceBreakdownUsdHr
+> = z.object({
+  compute: ComputePriceRange$outboundSchema,
+  volume: ComputePriceRange$outboundSchema,
+});
+
+export function priceBreakdownUsdHrToJSON(
+  priceBreakdownUsdHr: PriceBreakdownUsdHr,
+): string {
+  return JSON.stringify(
+    PriceBreakdownUsdHr$outboundSchema.parse(priceBreakdownUsdHr),
+  );
+}
+export function priceBreakdownUsdHrFromJSON(
+  jsonString: string,
+): SafeParseResult<PriceBreakdownUsdHr, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PriceBreakdownUsdHr$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PriceBreakdownUsdHr' from JSON`,
+  );
+}
+
 /** @internal */
 export const ComputeQuote$inboundSchema: z.ZodType<
   ComputeQuote,
@@ -41,12 +89,15 @@ export const ComputeQuote$inboundSchema: z.ZodType<
   observed_at: z.string().datetime({ offset: true }).transform(v =>
     new Date(v)
   ),
+  price_breakdown_usd_hr: z.lazy(() => PriceBreakdownUsdHr$inboundSchema)
+    .optional(),
   price_usd_hr: z.nullable(ComputePriceRange$inboundSchema),
   providers: z.array(ComputeProviderQuote$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "expires_at": "expiresAt",
     "observed_at": "observedAt",
+    "price_breakdown_usd_hr": "priceBreakdownUsdHr",
     "price_usd_hr": "priceUsdHr",
   });
 });
@@ -55,6 +106,7 @@ export type ComputeQuote$Outbound = {
   available: boolean;
   expires_at: string | null;
   observed_at: string;
+  price_breakdown_usd_hr?: PriceBreakdownUsdHr$Outbound | undefined;
   price_usd_hr: ComputePriceRange$Outbound | null;
   providers?: Array<ComputeProviderQuote$Outbound> | undefined;
 };
@@ -68,12 +120,15 @@ export const ComputeQuote$outboundSchema: z.ZodType<
   available: z.boolean(),
   expiresAt: z.nullable(z.date().transform(v => v.toISOString())),
   observedAt: z.date().transform(v => v.toISOString()),
+  priceBreakdownUsdHr: z.lazy(() => PriceBreakdownUsdHr$outboundSchema)
+    .optional(),
   priceUsdHr: z.nullable(ComputePriceRange$outboundSchema),
   providers: z.array(ComputeProviderQuote$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     expiresAt: "expires_at",
     observedAt: "observed_at",
+    priceBreakdownUsdHr: "price_breakdown_usd_hr",
     priceUsdHr: "price_usd_hr",
   });
 });

package/src/models/components/computequoterequest.ts

@@ -30,6 +30,12 @@ import {
   ComputeResourceType$inboundSchema,
   ComputeResourceType$outboundSchema,
 } from "./computeresourcetype.js";
+import {
+  ComputeVolumeInput,
+  ComputeVolumeInput$inboundSchema,
+  ComputeVolumeInput$Outbound,
+  ComputeVolumeInput$outboundSchema,
+} from "./computevolumeinput.js";
 
 export type ComputeQuoteRequestAccess = {
   ssh?: boolean | undefined;
@@ -40,12 +46,17 @@ export type ComputeQuoteRequestContainer = {
   ports?: Array<ComputePort> | undefined;
 };
 
+export type Service = {
+  volume?: ComputeVolumeInput | undefined;
+};
+
 export type ComputeQuoteRequest = {
   access?: ComputeQuoteRequestAccess | undefined;
   compute: ComputeRequest;
   container: ComputeQuoteRequestContainer;
   placement?: ComputePlacement | undefined;
   resourceType: ComputeResourceType;
+  service?: Service | undefined;
 };
 
 /** @internal */
@@ -131,6 +142,38 @@ export function computeQuoteRequestContainerFromJSON(
   );
 }
 
+/** @internal */
+export const Service$inboundSchema: z.ZodType<Service, z.ZodTypeDef, unknown> =
+  z.object({
+    volume: ComputeVolumeInput$inboundSchema.optional(),
+  });
+/** @internal */
+export type Service$Outbound = {
+  volume?: ComputeVolumeInput$Outbound | undefined;
+};
+
+/** @internal */
+export const Service$outboundSchema: z.ZodType<
+  Service$Outbound,
+  z.ZodTypeDef,
+  Service
+> = z.object({
+  volume: ComputeVolumeInput$outboundSchema.optional(),
+});
+
+export function serviceToJSON(service: Service): string {
+  return JSON.stringify(Service$outboundSchema.parse(service));
+}
+export function serviceFromJSON(
+  jsonString: string,
+): SafeParseResult<Service, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Service$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Service' from JSON`,
+  );
+}
+
 /** @internal */
 export const ComputeQuoteRequest$inboundSchema: z.ZodType<
   ComputeQuoteRequest,
@@ -142,6 +185,7 @@ export const ComputeQuoteRequest$inboundSchema: z.ZodType<
   container: z.lazy(() => ComputeQuoteRequestContainer$inboundSchema),
   placement: ComputePlacement$inboundSchema.optional(),
   resource_type: ComputeResourceType$inboundSchema,
+  service: z.lazy(() => Service$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "resource_type": "resourceType",
@@ -154,6 +198,7 @@ export type ComputeQuoteRequest$Outbound = {
   container: ComputeQuoteRequestContainer$Outbound;
   placement?: ComputePlacement$Outbound | undefined;
   resource_type: string;
+  service?: Service$Outbound | undefined;
 };
 
 /** @internal */
@@ -167,6 +212,7 @@ export const ComputeQuoteRequest$outboundSchema: z.ZodType<
   container: z.lazy(() => ComputeQuoteRequestContainer$outboundSchema),
   placement: ComputePlacement$outboundSchema.optional(),
   resourceType: ComputeResourceType$outboundSchema,
+  service: z.lazy(() => Service$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     resourceType: "resource_type",

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