@meetkai/mka1 0.51.39 → 0.53.1

package/src/models/components/agentrun.ts

@@ -8,12 +8,6 @@ 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 {
-  JsonValue,
-  JsonValue$inboundSchema,
-  JsonValue$Outbound,
-  JsonValue$outboundSchema,
-} from "./jsonvalue.js";
 
 export const AgentRunObject = {
   AgentRun: "agent.run",
@@ -37,13 +31,16 @@ export type AgentRun = {
    */
   agentVersion: number | null;
   status: AgentRunStatus;
-  input: JsonValue | null;
-  conversation: JsonValue | null;
+  /**
+   * Arbitrary JSON value.
+   */
+  input?: any | undefined;
+  conversation?: any | null | undefined;
   previousResponseId: string | null;
   metadata: { [k: string]: string } | null;
   gatewayResponseId: string | null;
-  gatewayResponse: JsonValue | null;
-  error: JsonValue | null;
+  gatewayResponse?: any | null | undefined;
+  error?: any | null | undefined;
   createdAt: Date;
   completedAt: Date | null;
 };
@@ -77,13 +74,13 @@ export const AgentRun$inboundSchema: z.ZodType<
   agent_id: z.string(),
   agent_version: z.nullable(z.number().int()),
   status: AgentRunStatus$inboundSchema,
-  input: z.nullable(JsonValue$inboundSchema),
-  conversation: z.nullable(JsonValue$inboundSchema),
+  input: z.any().optional(),
+  conversation: z.nullable(z.any()).optional(),
   previous_response_id: z.nullable(z.string()),
   metadata: z.nullable(z.record(z.string())),
   gateway_response_id: z.nullable(z.string()),
-  gateway_response: z.nullable(JsonValue$inboundSchema),
-  error: z.nullable(JsonValue$inboundSchema),
+  gateway_response: z.nullable(z.any()).optional(),
+  error: z.nullable(z.any()).optional(),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   completed_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
@@ -106,13 +103,13 @@ export type AgentRun$Outbound = {
   agent_id: string;
   agent_version: number | null;
   status: string;
-  input: JsonValue$Outbound | null;
-  conversation: JsonValue$Outbound | null;
+  input?: any | undefined;
+  conversation?: any | null | undefined;
   previous_response_id: string | null;
   metadata: { [k: string]: string } | null;
   gateway_response_id: string | null;
-  gateway_response: JsonValue$Outbound | null;
-  error: JsonValue$Outbound | null;
+  gateway_response?: any | null | undefined;
+  error?: any | null | undefined;
   created_at: string;
   completed_at: string | null;
 };
@@ -128,13 +125,13 @@ export const AgentRun$outboundSchema: z.ZodType<
   agentId: z.string(),
   agentVersion: z.nullable(z.number().int()),
   status: AgentRunStatus$outboundSchema,
-  input: z.nullable(JsonValue$outboundSchema),
-  conversation: z.nullable(JsonValue$outboundSchema),
+  input: z.any().optional(),
+  conversation: z.nullable(z.any()).optional(),
   previousResponseId: z.nullable(z.string()),
   metadata: z.nullable(z.record(z.string())),
   gatewayResponseId: z.nullable(z.string()),
-  gatewayResponse: z.nullable(JsonValue$outboundSchema),
-  error: z.nullable(JsonValue$outboundSchema),
+  gatewayResponse: z.nullable(z.any()).optional(),
+  error: z.nullable(z.any()).optional(),
   createdAt: z.date().transform(v => v.toISOString()),
   completedAt: z.nullable(z.date().transform(v => v.toISOString())),
 }).transform((v) => {

package/src/models/components/agentschedule.ts

@@ -20,12 +20,6 @@ import {
   AgentScheduleSpec$Outbound,
   AgentScheduleSpec$outboundSchema,
 } from "./agentschedulespec.js";
-import {
-  JsonValue,
-  JsonValue$inboundSchema,
-  JsonValue$Outbound,
-  JsonValue$outboundSchema,
-} from "./jsonvalue.js";
 
 export const AgentScheduleObject = {
   AgentSchedule: "agent.schedule",
@@ -47,8 +41,11 @@ export type AgentSchedule = {
   name: string | null;
   status: AgentScheduleStatus;
   schedule: AgentScheduleSpec;
-  input: JsonValue | null;
-  conversation: JsonValue | null;
+  /**
+   * Arbitrary JSON value.
+   */
+  input?: any | undefined;
+  conversation?: any | null | undefined;
   previousResponseId: string | null;
   contextManagement: Array<AgentCompactionContextManagement> | null;
   metadata: { [k: string]: string } | null;
@@ -91,8 +88,8 @@ export const AgentSchedule$inboundSchema: z.ZodType<
   name: z.nullable(z.string()),
   status: AgentScheduleStatus$inboundSchema,
   schedule: AgentScheduleSpec$inboundSchema,
-  input: z.nullable(JsonValue$inboundSchema),
-  conversation: z.nullable(JsonValue$inboundSchema),
+  input: z.any().optional(),
+  conversation: z.nullable(z.any()).optional(),
   previous_response_id: z.nullable(z.string()),
   context_management: z.nullable(
     z.array(AgentCompactionContextManagement$inboundSchema),
@@ -131,8 +128,8 @@ export type AgentSchedule$Outbound = {
   name: string | null;
   status: string;
   schedule: AgentScheduleSpec$Outbound;
-  input: JsonValue$Outbound | null;
-  conversation: JsonValue$Outbound | null;
+  input?: any | undefined;
+  conversation?: any | null | undefined;
   previous_response_id: string | null;
   context_management: Array<AgentCompactionContextManagement$Outbound> | null;
   metadata: { [k: string]: string } | null;
@@ -157,8 +154,8 @@ export const AgentSchedule$outboundSchema: z.ZodType<
   name: z.nullable(z.string()),
   status: AgentScheduleStatus$outboundSchema,
   schedule: AgentScheduleSpec$outboundSchema,
-  input: z.nullable(JsonValue$outboundSchema),
-  conversation: z.nullable(JsonValue$outboundSchema),
+  input: z.any().optional(),
+  conversation: z.nullable(z.any()).optional(),
   previousResponseId: z.nullable(z.string()),
   contextManagement: z.nullable(
     z.array(AgentCompactionContextManagement$outboundSchema),

package/src/models/components/agentversion.ts

@@ -20,12 +20,6 @@ import {
   AgentTextConfiguration$Outbound,
   AgentTextConfiguration$outboundSchema,
 } from "./agenttextconfiguration.js";
-import {
-  JsonValue,
-  JsonValue$inboundSchema,
-  JsonValue$Outbound,
-  JsonValue$outboundSchema,
-} from "./jsonvalue.js";
 import {
   ToolDefinition,
   ToolDefinition$inboundSchema,
@@ -56,7 +50,10 @@ export type AgentVersion = {
   model: string;
   instructions: string | null;
   tools: Array<ToolDefinition>;
-  toolChoice: JsonValue | null;
+  /**
+   * Arbitrary JSON value.
+   */
+  toolChoice?: any | undefined;
   parallelToolCalls: boolean;
   maxToolCalls: number | null;
   text: AgentTextConfiguration | null;
@@ -91,7 +88,7 @@ export const AgentVersion$inboundSchema: z.ZodType<
   model: z.string(),
   instructions: z.nullable(z.string()),
   tools: z.array(ToolDefinition$inboundSchema),
-  tool_choice: z.nullable(JsonValue$inboundSchema),
+  tool_choice: z.any().optional(),
   parallel_tool_calls: z.boolean(),
   max_tool_calls: z.nullable(z.number().int()),
   text: z.nullable(AgentTextConfiguration$inboundSchema),
@@ -122,7 +119,7 @@ export type AgentVersion$Outbound = {
   model: string;
   instructions: string | null;
   tools: Array<ToolDefinition$Outbound>;
-  tool_choice: JsonValue$Outbound | null;
+  tool_choice?: any | undefined;
   parallel_tool_calls: boolean;
   max_tool_calls: number | null;
   text: AgentTextConfiguration$Outbound | null;
@@ -148,7 +145,7 @@ export const AgentVersion$outboundSchema: z.ZodType<
   model: z.string(),
   instructions: z.nullable(z.string()),
   tools: z.array(ToolDefinition$outboundSchema),
-  toolChoice: z.nullable(JsonValue$outboundSchema),
+  toolChoice: z.any().optional(),
   parallelToolCalls: z.boolean(),
   maxToolCalls: z.nullable(z.number().int()),
   text: z.nullable(AgentTextConfiguration$outboundSchema),

package/src/models/components/computeoffer.ts

@@ -11,6 +11,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type ComputeOfferCapabilities = {
   customImage: boolean;
   httpPorts: boolean;
+  persistentVolume: boolean;
+  sharedVolume: boolean;
   ssh: boolean;
   tcpPorts: boolean;
 };
@@ -53,12 +55,16 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
 > = z.object({
   custom_image: z.boolean(),
   http_ports: z.boolean(),
+  persistent_volume: z.boolean(),
+  shared_volume: z.boolean(),
   ssh: z.boolean(),
   tcp_ports: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
     "custom_image": "customImage",
     "http_ports": "httpPorts",
+    "persistent_volume": "persistentVolume",
+    "shared_volume": "sharedVolume",
     "tcp_ports": "tcpPorts",
   });
 });
@@ -66,6 +72,8 @@ export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
 export type ComputeOfferCapabilities$Outbound = {
   custom_image: boolean;
   http_ports: boolean;
+  persistent_volume: boolean;
+  shared_volume: boolean;
   ssh: boolean;
   tcp_ports: boolean;
 };
@@ -78,12 +86,16 @@ export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
 > = z.object({
   customImage: z.boolean(),
   httpPorts: z.boolean(),
+  persistentVolume: z.boolean(),
+  sharedVolume: z.boolean(),
   ssh: z.boolean(),
   tcpPorts: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
     customImage: "custom_image",
     httpPorts: "http_ports",
+    persistentVolume: "persistent_volume",
+    sharedVolume: "shared_volume",
     tcpPorts: "tcp_ports",
   });
 });

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