@meetkai/mka1 0.54.5 → 0.54.7

package/src/models/components/computeusage.ts

@@ -5,13 +5,14 @@
 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 {
-  ComputeResourceType,
-  ComputeResourceType$inboundSchema,
-  ComputeResourceType$outboundSchema,
-} from "./computeresourcetype.js";
+  ComputeUsageResourceType,
+  ComputeUsageResourceType$inboundSchema,
+  ComputeUsageResourceType$outboundSchema,
+} from "./computeusageresourcetype.js";
 
 export type CostBreakdownUsd = {
   compute: number;
@@ -24,15 +25,53 @@ export type ComputeUsageData = {
   costBreakdownUsd?: CostBreakdownUsd | undefined;
   name: string;
   resourceId: string;
-  resourceType: ComputeResourceType;
+  resourceType: ComputeUsageResourceType;
+  storedByteSeconds?: number | undefined;
+  storedGibHours?: number | undefined;
 };
 
+/**
+ * Required alignment and allocation granularity of the requested window.
+ */
+export const Granularity = {
+  Minute: "minute",
+} as const;
+/**
+ * Required alignment and allocation granularity of the requested window.
+ */
+export type Granularity = ClosedEnum<typeof Granularity>;
+
 export type ComputeUsageSummary = {
   jobUsd: number;
   serviceUsd: number;
   totalUsd: number;
+  volumeUsd: number;
 };
 
+/**
+ * Finalized hourly volume totals are allocated uniformly over their immutable billable interval.
+ */
+export const VolumeAllocation = {
+  UniformProration: "uniform_proration",
+} as const;
+/**
+ * Finalized hourly volume totals are allocated uniformly over their immutable billable interval.
+ */
+export type VolumeAllocation = ClosedEnum<typeof VolumeAllocation>;
+
+/**
+ * Immutable UTC bucket granularity of standalone-volume billing rows.
+ */
+export const VolumeLedgerGranularity = {
+  Hour: "hour",
+} as const;
+/**
+ * Immutable UTC bucket granularity of standalone-volume billing rows.
+ */
+export type VolumeLedgerGranularity = ClosedEnum<
+  typeof VolumeLedgerGranularity
+>;
+
 export type Window = {
   from: Date;
   to: Date;
@@ -40,9 +79,29 @@ export type Window = {
 
 export type ComputeUsage = {
   data: Array<ComputeUsageData>;
+  /**
+   * Required alignment and allocation granularity of the requested window.
+   */
+  granularity: Granularity;
   nextCursor: string | null;
   summary: ComputeUsageSummary;
   total: number;
+  /**
+   * Finalized hourly volume totals are allocated uniformly over their immutable billable interval.
+   */
+  volumeAllocation: VolumeAllocation;
+  /**
+   * Immutable UTC bucket granularity of standalone-volume billing rows.
+   */
+  volumeLedgerGranularity: VolumeLedgerGranularity;
+  /**
+   * True only when every relevant standalone volume has a contiguous durable ledger prefix through window.to.
+   */
+  volumeUsageComplete: boolean;
+  /**
+   * Conservative organization-wide standalone-volume ledger watermark, capped to the requested window.
+   */
+  volumeUsageCompleteThrough: Date;
   window: Window;
 };
 
@@ -95,11 +154,13 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   accrued_usd: z.number(),
-  billable_seconds: z.number().int(),
+  billable_seconds: z.number(),
   cost_breakdown_usd: z.lazy(() => CostBreakdownUsd$inboundSchema).optional(),
   name: z.string(),
   resource_id: z.string(),
-  resource_type: ComputeResourceType$inboundSchema,
+  resource_type: ComputeUsageResourceType$inboundSchema,
+  stored_byte_seconds: z.number().optional(),
+  stored_gib_hours: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
     "accrued_usd": "accruedUsd",
@@ -107,6 +168,8 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
     "cost_breakdown_usd": "costBreakdownUsd",
     "resource_id": "resourceId",
     "resource_type": "resourceType",
+    "stored_byte_seconds": "storedByteSeconds",
+    "stored_gib_hours": "storedGibHours",
   });
 });
 /** @internal */
@@ -117,6 +180,8 @@ export type ComputeUsageData$Outbound = {
   name: string;
   resource_id: string;
   resource_type: string;
+  stored_byte_seconds?: number | undefined;
+  stored_gib_hours?: number | undefined;
 };
 
 /** @internal */
@@ -126,11 +191,13 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
   ComputeUsageData
 > = z.object({
   accruedUsd: z.number(),
-  billableSeconds: z.number().int(),
+  billableSeconds: z.number(),
   costBreakdownUsd: z.lazy(() => CostBreakdownUsd$outboundSchema).optional(),
   name: z.string(),
   resourceId: z.string(),
-  resourceType: ComputeResourceType$outboundSchema,
+  resourceType: ComputeUsageResourceType$outboundSchema,
+  storedByteSeconds: z.number().optional(),
+  storedGibHours: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
     accruedUsd: "accrued_usd",
@@ -138,6 +205,8 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
     costBreakdownUsd: "cost_breakdown_usd",
     resourceId: "resource_id",
     resourceType: "resource_type",
+    storedByteSeconds: "stored_byte_seconds",
+    storedGibHours: "stored_gib_hours",
   });
 });
 
@@ -158,6 +227,13 @@ export function computeUsageDataFromJSON(
   );
 }
 
+/** @internal */
+export const Granularity$inboundSchema: z.ZodNativeEnum<typeof Granularity> = z
+  .nativeEnum(Granularity);
+/** @internal */
+export const Granularity$outboundSchema: z.ZodNativeEnum<typeof Granularity> =
+  Granularity$inboundSchema;
+
 /** @internal */
 export const ComputeUsageSummary$inboundSchema: z.ZodType<
   ComputeUsageSummary,
@@ -167,11 +243,13 @@ export const ComputeUsageSummary$inboundSchema: z.ZodType<
   job_usd: z.number(),
   service_usd: z.number(),
   total_usd: z.number(),
+  volume_usd: z.number(),
 }).transform((v) => {
   return remap$(v, {
     "job_usd": "jobUsd",
     "service_usd": "serviceUsd",
     "total_usd": "totalUsd",
+    "volume_usd": "volumeUsd",
   });
 });
 /** @internal */
@@ -179,6 +257,7 @@ export type ComputeUsageSummary$Outbound = {
   job_usd: number;
   service_usd: number;
   total_usd: number;
+  volume_usd: number;
 };
 
 /** @internal */
@@ -190,11 +269,13 @@ export const ComputeUsageSummary$outboundSchema: z.ZodType<
   jobUsd: z.number(),
   serviceUsd: z.number(),
   totalUsd: z.number(),
+  volumeUsd: z.number(),
 }).transform((v) => {
   return remap$(v, {
     jobUsd: "job_usd",
     serviceUsd: "service_usd",
     totalUsd: "total_usd",
+    volumeUsd: "volume_usd",
   });
 });
 
@@ -215,6 +296,24 @@ export function computeUsageSummaryFromJSON(
   );
 }
 
+/** @internal */
+export const VolumeAllocation$inboundSchema: z.ZodNativeEnum<
+  typeof VolumeAllocation
+> = z.nativeEnum(VolumeAllocation);
+/** @internal */
+export const VolumeAllocation$outboundSchema: z.ZodNativeEnum<
+  typeof VolumeAllocation
+> = VolumeAllocation$inboundSchema;
+
+/** @internal */
+export const VolumeLedgerGranularity$inboundSchema: z.ZodNativeEnum<
+  typeof VolumeLedgerGranularity
+> = z.nativeEnum(VolumeLedgerGranularity);
+/** @internal */
+export const VolumeLedgerGranularity$outboundSchema: z.ZodNativeEnum<
+  typeof VolumeLedgerGranularity
+> = VolumeLedgerGranularity$inboundSchema;
+
 /** @internal */
 export const Window$inboundSchema: z.ZodType<Window, z.ZodTypeDef, unknown> = z
   .object({
@@ -257,21 +356,36 @@ export const ComputeUsage$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.array(z.lazy(() => ComputeUsageData$inboundSchema)),
+  granularity: Granularity$inboundSchema,
   next_cursor: z.nullable(z.string()),
   summary: z.lazy(() => ComputeUsageSummary$inboundSchema),
   total: z.number().int(),
+  volume_allocation: VolumeAllocation$inboundSchema,
+  volume_ledger_granularity: VolumeLedgerGranularity$inboundSchema,
+  volume_usage_complete: z.boolean(),
+  volume_usage_complete_through: z.string().datetime({ offset: true })
+    .transform(v => new Date(v)),
   window: z.lazy(() => Window$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "next_cursor": "nextCursor",
+    "volume_allocation": "volumeAllocation",
+    "volume_ledger_granularity": "volumeLedgerGranularity",
+    "volume_usage_complete": "volumeUsageComplete",
+    "volume_usage_complete_through": "volumeUsageCompleteThrough",
   });
 });
 /** @internal */
 export type ComputeUsage$Outbound = {
   data: Array<ComputeUsageData$Outbound>;
+  granularity: string;
   next_cursor: string | null;
   summary: ComputeUsageSummary$Outbound;
   total: number;
+  volume_allocation: string;
+  volume_ledger_granularity: string;
+  volume_usage_complete: boolean;
+  volume_usage_complete_through: string;
   window: Window$Outbound;
 };
 
@@ -282,13 +396,22 @@ export const ComputeUsage$outboundSchema: z.ZodType<
   ComputeUsage
 > = z.object({
   data: z.array(z.lazy(() => ComputeUsageData$outboundSchema)),
+  granularity: Granularity$outboundSchema,
   nextCursor: z.nullable(z.string()),
   summary: z.lazy(() => ComputeUsageSummary$outboundSchema),
   total: z.number().int(),
+  volumeAllocation: VolumeAllocation$outboundSchema,
+  volumeLedgerGranularity: VolumeLedgerGranularity$outboundSchema,
+  volumeUsageComplete: z.boolean(),
+  volumeUsageCompleteThrough: z.date().transform(v => v.toISOString()),
   window: z.lazy(() => Window$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     nextCursor: "next_cursor",
+    volumeAllocation: "volume_allocation",
+    volumeLedgerGranularity: "volume_ledger_granularity",
+    volumeUsageComplete: "volume_usage_complete",
+    volumeUsageCompleteThrough: "volume_usage_complete_through",
   });
 });
 

package/src/models/components/computeusageresourcetype.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ComputeUsageResourceType = {
+  Job: "job",
+  Service: "service",
+  Volume: "volume",
+} as const;
+export type ComputeUsageResourceType = ClosedEnum<
+  typeof ComputeUsageResourceType
+>;
+
+/** @internal */
+export const ComputeUsageResourceType$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeUsageResourceType
+> = z.nativeEnum(ComputeUsageResourceType);
+/** @internal */
+export const ComputeUsageResourceType$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeUsageResourceType
+> = ComputeUsageResourceType$inboundSchema;

package/src/models/components/index.ts

@@ -100,6 +100,8 @@ export * from "./computeplacement.js";
 export * from "./computeplacementstrategy.js";
 export * from "./computeport.js";
 export * from "./computepricerange.js";
+export * from "./computepricing.js";
+export * from "./computepricingupdate.js";
 export * from "./computeproviderhealth.js";
 export * from "./computeproviderhealthlist.js";
 export * from "./computeproviderquote.js";
@@ -127,10 +129,19 @@ export * from "./computeservice.js";
 export * from "./computeserviceinput.js";
 export * from "./computeservicelist.js";
 export * from "./computessh.js";
+export * from "./computestandalonevolume.js";
+export * from "./computestandalonevolumeattachment.js";
+export * from "./computestandalonevolumeattachmentlist.js";
+export * from "./computestandalonevolumeattachmentstate.js";
+export * from "./computestandalonevolumecreate.js";
+export * from "./computestandalonevolumelist.js";
+export * from "./computestandalonevolumemount.js";
+export * from "./computestandalonevolumestate.js";
 export * from "./computetenant.js";
 export * from "./computetenantlist.js";
 export * from "./computetenantupdate.js";
 export * from "./computeusage.js";
+export * from "./computeusageresourcetype.js";
 export * from "./computevolume.js";
 export * from "./computevolumedata.js";
 export * from "./computevolumedatainput.js";

package/src/models/components/responsescreaterequest.ts

@@ -295,6 +295,10 @@ export type ResponsesCreateRequest = {
    * Additional options for configuring streaming behavior when stream is enabled.
    */
   streamOptions?: ResponsesCreateRequestStreamOptions | null | undefined;
+  /**
+   * Gateway extension. When true, provider calls are streamed even when `stream` is false, so per-token delta events are published to the response's event channel and visible via GET /responses/{id}?stream=true. Does not change the shape of this endpoint's HTTP response. Only valid when background=true; foreground requests are rejected. Defaults to false.
+   */
+  streamEvents?: boolean | undefined;
   /**
    * Whether to store the generated response for later retrieval. When true, the response is saved and can be retrieved via GET /responses/{id}. When false, the response is not persisted after generation. Defaults to true.
    */
@@ -812,6 +816,7 @@ export const ResponsesCreateRequest$inboundSchema: z.ZodType<
   stream_options: z.nullable(
     z.lazy(() => ResponsesCreateRequestStreamOptions$inboundSchema),
   ).optional(),
+  stream_events: z.boolean().optional(),
   store: z.boolean().default(true),
   background: z.boolean().default(false),
   webhook_url: z.string().optional(),
@@ -869,6 +874,7 @@ export const ResponsesCreateRequest$inboundSchema: z.ZodType<
   return remap$(v, {
     "previous_response_id": "previousResponseId",
     "stream_options": "streamOptions",
+    "stream_events": "streamEvents",
     "webhook_url": "webhookUrl",
     "webhook_secret": "webhookSecret",
     "tool_choice": "toolChoice",
@@ -910,6 +916,7 @@ export type ResponsesCreateRequest$Outbound = {
     | ResponsesCreateRequestStreamOptions$Outbound
     | null
     | undefined;
+  stream_events?: boolean | undefined;
   store: boolean;
   background: boolean;
   webhook_url?: string | undefined;
@@ -983,6 +990,7 @@ export const ResponsesCreateRequest$outboundSchema: z.ZodType<
   streamOptions: z.nullable(
     z.lazy(() => ResponsesCreateRequestStreamOptions$outboundSchema),
   ).optional(),
+  streamEvents: z.boolean().optional(),
   store: z.boolean().default(true),
   background: z.boolean().default(false),
   webhookUrl: z.string().optional(),
@@ -1040,6 +1048,7 @@ export const ResponsesCreateRequest$outboundSchema: z.ZodType<
   return remap$(v, {
     previousResponseId: "previous_response_id",
     streamOptions: "stream_options",
+    streamEvents: "stream_events",
     webhookUrl: "webhook_url",
     webhookSecret: "webhook_secret",
     toolChoice: "tool_choice",

package/src/models/operations/createstandalonevolume.ts

@@ -0,0 +1,128 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateStandaloneVolumeRequest = {
+  idempotencyKey: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  computeStandaloneVolumeCreate: components.ComputeStandaloneVolumeCreate;
+};
+
+export type CreateStandaloneVolumeResponse =
+  | components.ComputeStandaloneVolume
+  | components.ComputeErrorEnvelope;
+
+/** @internal */
+export const CreateStandaloneVolumeRequest$inboundSchema: z.ZodType<
+  CreateStandaloneVolumeRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "Idempotency-Key": z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+  ComputeStandaloneVolumeCreate:
+    components.ComputeStandaloneVolumeCreate$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Idempotency-Key": "idempotencyKey",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "ComputeStandaloneVolumeCreate": "computeStandaloneVolumeCreate",
+  });
+});
+/** @internal */
+export type CreateStandaloneVolumeRequest$Outbound = {
+  "Idempotency-Key": string;
+  "X-On-Behalf-Of"?: string | undefined;
+  ComputeStandaloneVolumeCreate:
+    components.ComputeStandaloneVolumeCreate$Outbound;
+};
+
+/** @internal */
+export const CreateStandaloneVolumeRequest$outboundSchema: z.ZodType<
+  CreateStandaloneVolumeRequest$Outbound,
+  z.ZodTypeDef,
+  CreateStandaloneVolumeRequest
+> = z.object({
+  idempotencyKey: z.string(),
+  xOnBehalfOf: z.string().optional(),
+  computeStandaloneVolumeCreate:
+    components.ComputeStandaloneVolumeCreate$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "Idempotency-Key",
+    xOnBehalfOf: "X-On-Behalf-Of",
+    computeStandaloneVolumeCreate: "ComputeStandaloneVolumeCreate",
+  });
+});
+
+export function createStandaloneVolumeRequestToJSON(
+  createStandaloneVolumeRequest: CreateStandaloneVolumeRequest,
+): string {
+  return JSON.stringify(
+    CreateStandaloneVolumeRequest$outboundSchema.parse(
+      createStandaloneVolumeRequest,
+    ),
+  );
+}
+export function createStandaloneVolumeRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateStandaloneVolumeRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateStandaloneVolumeRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateStandaloneVolumeRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateStandaloneVolumeResponse$inboundSchema: z.ZodType<
+  CreateStandaloneVolumeResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ComputeStandaloneVolume$inboundSchema,
+  components.ComputeErrorEnvelope$inboundSchema,
+]);
+/** @internal */
+export type CreateStandaloneVolumeResponse$Outbound =
+  | components.ComputeStandaloneVolume$Outbound
+  | components.ComputeErrorEnvelope$Outbound;
+
+/** @internal */
+export const CreateStandaloneVolumeResponse$outboundSchema: z.ZodType<
+  CreateStandaloneVolumeResponse$Outbound,
+  z.ZodTypeDef,
+  CreateStandaloneVolumeResponse
+> = z.union([
+  components.ComputeStandaloneVolume$outboundSchema,
+  components.ComputeErrorEnvelope$outboundSchema,
+]);
+
+export function createStandaloneVolumeResponseToJSON(
+  createStandaloneVolumeResponse: CreateStandaloneVolumeResponse,
+): string {
+  return JSON.stringify(
+    CreateStandaloneVolumeResponse$outboundSchema.parse(
+      createStandaloneVolumeResponse,
+    ),
+  );
+}
+export function createStandaloneVolumeResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateStandaloneVolumeResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateStandaloneVolumeResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateStandaloneVolumeResponse' from JSON`,
+  );
+}

package/src/models/operations/deletestandalonevolume.ts

@@ -0,0 +1,117 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeleteStandaloneVolumeRequest = {
+  id: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+export type DeleteStandaloneVolumeResponse =
+  | components.ComputeStandaloneVolume
+  | components.ComputeErrorEnvelope;
+
+/** @internal */
+export const DeleteStandaloneVolumeRequest$inboundSchema: z.ZodType<
+  DeleteStandaloneVolumeRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type DeleteStandaloneVolumeRequest$Outbound = {
+  id: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const DeleteStandaloneVolumeRequest$outboundSchema: z.ZodType<
+  DeleteStandaloneVolumeRequest$Outbound,
+  z.ZodTypeDef,
+  DeleteStandaloneVolumeRequest
+> = z.object({
+  id: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function deleteStandaloneVolumeRequestToJSON(
+  deleteStandaloneVolumeRequest: DeleteStandaloneVolumeRequest,
+): string {
+  return JSON.stringify(
+    DeleteStandaloneVolumeRequest$outboundSchema.parse(
+      deleteStandaloneVolumeRequest,
+    ),
+  );
+}
+export function deleteStandaloneVolumeRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteStandaloneVolumeRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteStandaloneVolumeRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteStandaloneVolumeRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteStandaloneVolumeResponse$inboundSchema: z.ZodType<
+  DeleteStandaloneVolumeResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ComputeStandaloneVolume$inboundSchema,
+  components.ComputeErrorEnvelope$inboundSchema,
+]);
+/** @internal */
+export type DeleteStandaloneVolumeResponse$Outbound =
+  | components.ComputeStandaloneVolume$Outbound
+  | components.ComputeErrorEnvelope$Outbound;
+
+/** @internal */
+export const DeleteStandaloneVolumeResponse$outboundSchema: z.ZodType<
+  DeleteStandaloneVolumeResponse$Outbound,
+  z.ZodTypeDef,
+  DeleteStandaloneVolumeResponse
+> = z.union([
+  components.ComputeStandaloneVolume$outboundSchema,
+  components.ComputeErrorEnvelope$outboundSchema,
+]);
+
+export function deleteStandaloneVolumeResponseToJSON(
+  deleteStandaloneVolumeResponse: DeleteStandaloneVolumeResponse,
+): string {
+  return JSON.stringify(
+    DeleteStandaloneVolumeResponse$outboundSchema.parse(
+      deleteStandaloneVolumeResponse,
+    ),
+  );
+}
+export function deleteStandaloneVolumeResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteStandaloneVolumeResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteStandaloneVolumeResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteStandaloneVolumeResponse' from JSON`,
+  );
+}

package/src/models/operations/getcomputeusage.ts

@@ -10,9 +10,15 @@ import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetComputeUsageRequest = {
+  /**
+   * Inclusive RFC 3339 timestamp on an exact UTC minute boundary; never rounded.
+   */
   from?: Date | undefined;
+  /**
+   * Exclusive RFC 3339 timestamp on an exact UTC minute boundary; never rounded and cannot be later than the server's current UTC minute boundary.
+   */
   to?: Date | undefined;
-  resourceType?: components.ComputeResourceType | undefined;
+  resourceType?: components.ComputeUsageResourceType | undefined;
   cursor?: string | undefined;
   limit?: number | undefined;
   /**
@@ -35,7 +41,7 @@ export const GetComputeUsageRequest$inboundSchema: z.ZodType<
     .optional(),
   to: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
-  resource_type: components.ComputeResourceType$inboundSchema.optional(),
+  resource_type: components.ComputeUsageResourceType$inboundSchema.optional(),
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   "X-On-Behalf-Of": z.string().optional(),
@@ -63,7 +69,7 @@ export const GetComputeUsageRequest$outboundSchema: z.ZodType<
 > = z.object({
   from: z.date().transform(v => v.toISOString()).optional(),
   to: z.date().transform(v => v.toISOString()).optional(),
-  resourceType: components.ComputeResourceType$outboundSchema.optional(),
+  resourceType: components.ComputeUsageResourceType$outboundSchema.optional(),
   cursor: z.string().optional(),
   limit: z.number().int().default(50),
   xOnBehalfOf: z.string().optional(),