@meetkai/mka1 0.54.6 → 0.54.8

package/src/models/components/tooldefinition.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -83,11 +85,18 @@ export type Environment1 = {
   memoryStores?: Array<MemoryStores> | undefined;
 };
 
-export type Environment = Environment1 | Environment2;
+export type Environment =
+  | Environment1
+  | Environment2
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type Seven = {
   type: ToolDefinition7Type;
-  environment?: Environment1 | Environment2 | undefined;
+  environment?:
+    | Environment1
+    | Environment2
+    | discriminatedUnionTypes.Unknown<"type">
+    | undefined;
 };
 
 export const ToolDefinition6Type = {
@@ -124,7 +133,8 @@ export type ToolDefinition4Filters =
   | (FileSearchComparisonFilter & { type: "lt" })
   | (FileSearchComparisonFilter & { type: "lte" })
   | (FileSearchCompoundFilter & { type: "and" })
-  | (FileSearchCompoundFilter & { type: "or" });
+  | (FileSearchCompoundFilter & { type: "or" })
+  | discriminatedUnionTypes.Unknown<"type">;
 
 export type ToolDefinitionRankingOptions = {
   ranker?: string | undefined;
@@ -143,6 +153,7 @@ export type ToolDefinition4 = {
     | (FileSearchComparisonFilter & { type: "lte" })
     | (FileSearchCompoundFilter & { type: "and" })
     | (FileSearchCompoundFilter & { type: "or" })
+    | discriminatedUnionTypes.Unknown<"type">
     | undefined;
   maxNumResults?: number | undefined;
   rankingOptions?: ToolDefinitionRankingOptions | undefined;
@@ -549,10 +560,10 @@ export const Environment$inboundSchema: z.ZodType<
   Environment,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  z.lazy(() => Environment1$inboundSchema),
-  z.lazy(() => Environment2$inboundSchema),
-]);
+> = discriminatedUnion("type", {
+  container_auto: z.lazy(() => Environment1$inboundSchema),
+  container_reference: z.lazy(() => Environment2$inboundSchema),
+});
 /** @internal */
 export type Environment$Outbound =
   | Environment1$Outbound
@@ -585,10 +596,10 @@ export function environmentFromJSON(
 export const Seven$inboundSchema: z.ZodType<Seven, z.ZodTypeDef, unknown> = z
   .object({
     type: ToolDefinition7Type$inboundSchema,
-    environment: z.union([
-      z.lazy(() => Environment1$inboundSchema),
-      z.lazy(() => Environment2$inboundSchema),
-    ]).optional(),
+    environment: discriminatedUnion("type", {
+      container_auto: z.lazy(() => Environment1$inboundSchema),
+      container_reference: z.lazy(() => Environment2$inboundSchema),
+    }).optional(),
   });
 /** @internal */
 export type Seven$Outbound = {
@@ -728,32 +739,32 @@ export const ToolDefinition4Filters$inboundSchema: z.ZodType<
   ToolDefinition4Filters,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  FileSearchComparisonFilter$inboundSchema.and(
+> = discriminatedUnion("type", {
+  eq: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("eq") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  ne: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("ne") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  gt: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("gt") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  gte: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("gte") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  lt: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("lt") }),
   ),
-  FileSearchComparisonFilter$inboundSchema.and(
+  lte: FileSearchComparisonFilter$inboundSchema.and(
     z.object({ type: z.literal("lte") }),
   ),
-  FileSearchCompoundFilter$inboundSchema.and(
+  and: FileSearchCompoundFilter$inboundSchema.and(
     z.object({ type: z.literal("and") }),
   ),
-  FileSearchCompoundFilter$inboundSchema.and(
+  or: FileSearchCompoundFilter$inboundSchema.and(
     z.object({ type: z.literal("or") }),
   ),
-]);
+});
 /** @internal */
 export type ToolDefinition4Filters$Outbound =
   | (FileSearchComparisonFilter$Outbound & { type: "eq" })
@@ -874,32 +885,32 @@ export const ToolDefinition4$inboundSchema: z.ZodType<
 > = z.object({
   type: ToolDefinition4Type$inboundSchema,
   vector_store_ids: z.array(z.string()),
-  filters: z.union([
-    FileSearchComparisonFilter$inboundSchema.and(
+  filters: discriminatedUnion("type", {
+    eq: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("eq") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    ne: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("ne") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    gt: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("gt") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    gte: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("gte") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    lt: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("lt") }),
     ),
-    FileSearchComparisonFilter$inboundSchema.and(
+    lte: FileSearchComparisonFilter$inboundSchema.and(
       z.object({ type: z.literal("lte") }),
     ),
-    FileSearchCompoundFilter$inboundSchema.and(
+    and: FileSearchCompoundFilter$inboundSchema.and(
       z.object({ type: z.literal("and") }),
     ),
-    FileSearchCompoundFilter$inboundSchema.and(
+    or: FileSearchCompoundFilter$inboundSchema.and(
       z.object({ type: z.literal("or") }),
     ),
-  ]).optional(),
+  }).optional(),
   max_num_results: z.number().int().optional(),
   ranking_options: z.lazy(() => ToolDefinitionRankingOptions$inboundSchema)
     .optional(),

package/src/models/components/websearchaction.ts

@@ -4,6 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -25,18 +27,22 @@ import {
   SearchAction$outboundSchema,
 } from "./searchaction.js";
 
-export type WebSearchAction = SearchAction | OpenPageAction | FindAction;
+export type WebSearchAction =
+  | SearchAction
+  | OpenPageAction
+  | FindAction
+  | discriminatedUnionTypes.Unknown<"type">;
 
 /** @internal */
 export const WebSearchAction$inboundSchema: z.ZodType<
   WebSearchAction,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  SearchAction$inboundSchema,
-  OpenPageAction$inboundSchema,
-  FindAction$inboundSchema,
-]);
+> = discriminatedUnion("type", {
+  search: SearchAction$inboundSchema,
+  open_page: OpenPageAction$inboundSchema,
+  find: FindAction$inboundSchema,
+});
 /** @internal */
 export type WebSearchAction$Outbound =
   | SearchAction$Outbound

package/src/models/operations/createchatcompletionstream.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import * as discriminatedUnionTypes from "../../types/discriminatedUnion.js";
+import { discriminatedUnion } from "../../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -45,7 +47,11 @@ export type One = {
 /**
  * OK
  */
-export type CreateChatCompletionStreamResponseBody = One | Two | Three;
+export type CreateChatCompletionStreamResponseBody =
+  | One
+  | Two
+  | Three
+  | discriminatedUnionTypes.Unknown<"event">;
 
 /** @internal */
 export const CreateChatCompletionStreamRequest$inboundSchema: z.ZodType<
@@ -234,11 +240,11 @@ export const CreateChatCompletionStreamResponseBody$inboundSchema: z.ZodType<
   CreateChatCompletionStreamResponseBody,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  z.lazy(() => One$inboundSchema),
-  z.lazy(() => Two$inboundSchema),
-  z.lazy(() => Three$inboundSchema),
-]);
+> = discriminatedUnion("event", {
+  message: z.lazy(() => One$inboundSchema),
+  done: z.lazy(() => Two$inboundSchema),
+  error: z.lazy(() => Three$inboundSchema),
+});
 /** @internal */
 export type CreateChatCompletionStreamResponseBody$Outbound =
   | One$Outbound

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(),

package/src/models/operations/getpricing.ts

@@ -0,0 +1,174 @@
+/*
+ * 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 GetPricingRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+export type GetPricingResponseResult =
+  | components.ComputePricing
+  | components.ComputeErrorEnvelope;
+
+export type GetPricingResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.ComputePricing | components.ComputeErrorEnvelope;
+};
+
+/** @internal */
+export const GetPricingRequest$inboundSchema: z.ZodType<
+  GetPricingRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type GetPricingRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const GetPricingRequest$outboundSchema: z.ZodType<
+  GetPricingRequest$Outbound,
+  z.ZodTypeDef,
+  GetPricingRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function getPricingRequestToJSON(
+  getPricingRequest: GetPricingRequest,
+): string {
+  return JSON.stringify(
+    GetPricingRequest$outboundSchema.parse(getPricingRequest),
+  );
+}
+export function getPricingRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPricingRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPricingRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPricingRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPricingResponseResult$inboundSchema: z.ZodType<
+  GetPricingResponseResult,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ComputePricing$inboundSchema,
+  components.ComputeErrorEnvelope$inboundSchema,
+]);
+/** @internal */
+export type GetPricingResponseResult$Outbound =
+  | components.ComputePricing$Outbound
+  | components.ComputeErrorEnvelope$Outbound;
+
+/** @internal */
+export const GetPricingResponseResult$outboundSchema: z.ZodType<
+  GetPricingResponseResult$Outbound,
+  z.ZodTypeDef,
+  GetPricingResponseResult
+> = z.union([
+  components.ComputePricing$outboundSchema,
+  components.ComputeErrorEnvelope$outboundSchema,
+]);
+
+export function getPricingResponseResultToJSON(
+  getPricingResponseResult: GetPricingResponseResult,
+): string {
+  return JSON.stringify(
+    GetPricingResponseResult$outboundSchema.parse(getPricingResponseResult),
+  );
+}
+export function getPricingResponseResultFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPricingResponseResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPricingResponseResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPricingResponseResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPricingResponse$inboundSchema: z.ZodType<
+  GetPricingResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: z.union([
+    components.ComputePricing$inboundSchema,
+    components.ComputeErrorEnvelope$inboundSchema,
+  ]),
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+/** @internal */
+export type GetPricingResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result:
+    | components.ComputePricing$Outbound
+    | components.ComputeErrorEnvelope$Outbound;
+};
+
+/** @internal */
+export const GetPricingResponse$outboundSchema: z.ZodType<
+  GetPricingResponse$Outbound,
+  z.ZodTypeDef,
+  GetPricingResponse
+> = z.object({
+  headers: z.record(z.array(z.string())),
+  result: z.union([
+    components.ComputePricing$outboundSchema,
+    components.ComputeErrorEnvelope$outboundSchema,
+  ]),
+}).transform((v) => {
+  return remap$(v, {
+    headers: "Headers",
+    result: "Result",
+  });
+});
+
+export function getPricingResponseToJSON(
+  getPricingResponse: GetPricingResponse,
+): string {
+  return JSON.stringify(
+    GetPricingResponse$outboundSchema.parse(getPricingResponse),
+  );
+}
+export function getPricingResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPricingResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPricingResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPricingResponse' from JSON`,
+  );
+}