@leonardo-ai/sdk 4.18.0 → 4.19.0

package/src/sdk/models/operations/performinstantrefine.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 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 * as shared from "../shared/index.js";
 
 /**
@@ -144,6 +147,26 @@ export namespace PerformInstantRefineRequestBody$ {
   export type Outbound = PerformInstantRefineRequestBody$Outbound;
 }
 
+export function performInstantRefineRequestBodyToJSON(
+  performInstantRefineRequestBody: PerformInstantRefineRequestBody,
+): string {
+  return JSON.stringify(
+    PerformInstantRefineRequestBody$outboundSchema.parse(
+      performInstantRefineRequestBody,
+    ),
+  );
+}
+
+export function performInstantRefineRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformInstantRefineRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformInstantRefineRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformInstantRefineRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformInstantRefineLcmGenerationOutput$inboundSchema: z.ZodType<
   PerformInstantRefineLcmGenerationOutput,
@@ -188,6 +211,33 @@ export namespace PerformInstantRefineLcmGenerationOutput$ {
   export type Outbound = PerformInstantRefineLcmGenerationOutput$Outbound;
 }
 
+export function performInstantRefineLcmGenerationOutputToJSON(
+  performInstantRefineLcmGenerationOutput:
+    PerformInstantRefineLcmGenerationOutput,
+): string {
+  return JSON.stringify(
+    PerformInstantRefineLcmGenerationOutput$outboundSchema.parse(
+      performInstantRefineLcmGenerationOutput,
+    ),
+  );
+}
+
+export function performInstantRefineLcmGenerationOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PerformInstantRefineLcmGenerationOutput,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PerformInstantRefineLcmGenerationOutput$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PerformInstantRefineLcmGenerationOutput' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformInstantRefineResponseBody$inboundSchema: z.ZodType<
   PerformInstantRefineResponseBody,
@@ -231,6 +281,26 @@ export namespace PerformInstantRefineResponseBody$ {
   export type Outbound = PerformInstantRefineResponseBody$Outbound;
 }
 
+export function performInstantRefineResponseBodyToJSON(
+  performInstantRefineResponseBody: PerformInstantRefineResponseBody,
+): string {
+  return JSON.stringify(
+    PerformInstantRefineResponseBody$outboundSchema.parse(
+      performInstantRefineResponseBody,
+    ),
+  );
+}
+
+export function performInstantRefineResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformInstantRefineResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformInstantRefineResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformInstantRefineResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformInstantRefineResponse$inboundSchema: z.ZodType<
   PerformInstantRefineResponse,
@@ -291,3 +361,23 @@ export namespace PerformInstantRefineResponse$ {
   /** @deprecated use `PerformInstantRefineResponse$Outbound` instead. */
   export type Outbound = PerformInstantRefineResponse$Outbound;
 }
+
+export function performInstantRefineResponseToJSON(
+  performInstantRefineResponse: PerformInstantRefineResponse,
+): string {
+  return JSON.stringify(
+    PerformInstantRefineResponse$outboundSchema.parse(
+      performInstantRefineResponse,
+    ),
+  );
+}
+
+export function performInstantRefineResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformInstantRefineResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformInstantRefineResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformInstantRefineResponse' from JSON`,
+  );
+}

package/src/sdk/models/operations/pricingcalculator.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 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 * as shared from "../shared/index.js";
 
 /**
@@ -320,6 +323,24 @@ export namespace PricingCalculatorObject$ {
   export type Outbound = PricingCalculatorObject$Outbound;
 }
 
+export function pricingCalculatorObjectToJSON(
+  pricingCalculatorObject: PricingCalculatorObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorObject$outboundSchema.parse(pricingCalculatorObject),
+  );
+}
+
+export function pricingCalculatorObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<PricingCalculatorObject, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PricingCalculatorObject$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorObject$inboundSchema: z.ZodType<
   PricingCalculatorPricingCalculatorObject,
@@ -403,6 +424,33 @@ export namespace PricingCalculatorPricingCalculatorObject$ {
   export type Outbound = PricingCalculatorPricingCalculatorObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorObjectToJSON(
+  pricingCalculatorPricingCalculatorObject:
+    PricingCalculatorPricingCalculatorObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorObject$outboundSchema.parse(
+      pricingCalculatorPricingCalculatorObject,
+    ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorObject$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PricingCalculatorPricingCalculatorObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestObject$inboundSchema:
   z.ZodType<
@@ -453,6 +501,33 @@ export namespace PricingCalculatorPricingCalculatorRequestObject$ {
     PricingCalculatorPricingCalculatorRequestObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestObject:
+    PricingCalculatorPricingCalculatorRequestObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestObject$outboundSchema.parse(
+      pricingCalculatorPricingCalculatorRequestObject,
+    ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestObject$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestRequestBodyObject$inboundSchema:
   z.ZodType<
@@ -495,6 +570,31 @@ export namespace PricingCalculatorPricingCalculatorRequestRequestBodyObject$ {
     PricingCalculatorPricingCalculatorRequestRequestBodyObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestRequestBodyObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestRequestBodyObject:
+    PricingCalculatorPricingCalculatorRequestRequestBodyObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestRequestBodyObject$outboundSchema
+      .parse(pricingCalculatorPricingCalculatorRequestRequestBodyObject),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestRequestBodyObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestRequestBodyObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestRequestBodyObject$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestRequestBodyObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject$inboundSchema:
   z.ZodType<
@@ -537,6 +637,33 @@ export namespace PricingCalculatorPricingCalculatorRequestRequestBodyServicePara
     PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject:
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject$outboundSchema
+      .parse(
+        pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject,
+      ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject$inboundSchema:
   z.ZodType<
@@ -579,6 +706,33 @@ export namespace PricingCalculatorPricingCalculatorRequestRequestBodyServicePara
     PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject:
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject$outboundSchema
+      .parse(
+        pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject,
+      ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsTEXTUREGENERATIONObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject$inboundSchema:
   z.ZodType<
@@ -621,6 +775,33 @@ export namespace PricingCalculatorPricingCalculatorRequestRequestBodyServicePara
     PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject:
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject$outboundSchema
+      .parse(
+        pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject,
+      ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject$inboundSchema:
   z.ZodType<
@@ -669,6 +850,33 @@ export namespace PricingCalculatorPricingCalculatorRequestRequestBodyServicePara
     PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject$Outbound;
 }
 
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObjectToJSON(
+  pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject:
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject,
+): string {
+  return JSON.stringify(
+    PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject$outboundSchema
+      .parse(
+        pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject,
+      ),
+  );
+}
+
+export function pricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorPricingCalculatorRequestRequestBodyServiceParamsUNIVERSALUPSCALERULTRAObject' from JSON`,
+  );
+}
+
 /** @internal */
 export const ObjectT$inboundSchema: z.ZodType<ObjectT, z.ZodTypeDef, unknown> =
   z.object({
@@ -825,6 +1033,20 @@ export namespace ObjectT$ {
   export type Outbound = ObjectT$Outbound;
 }
 
+export function objectToJSON(objectT: ObjectT): string {
+  return JSON.stringify(ObjectT$outboundSchema.parse(objectT));
+}
+
+export function objectFromJSON(
+  jsonString: string,
+): SafeParseResult<ObjectT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ObjectT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ObjectT' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorRequestBody$inboundSchema: z.ZodType<
   PricingCalculatorRequestBody,
@@ -864,6 +1086,26 @@ export namespace PricingCalculatorRequestBody$ {
   export type Outbound = PricingCalculatorRequestBody$Outbound;
 }
 
+export function pricingCalculatorRequestBodyToJSON(
+  pricingCalculatorRequestBody: PricingCalculatorRequestBody,
+): string {
+  return JSON.stringify(
+    PricingCalculatorRequestBody$outboundSchema.parse(
+      pricingCalculatorRequestBody,
+    ),
+  );
+}
+
+export function pricingCalculatorRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PricingCalculatorRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PricingCalculatorRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CalculateProductionApiServiceCost$inboundSchema: z.ZodType<
   CalculateProductionApiServiceCost,
@@ -901,6 +1143,26 @@ export namespace CalculateProductionApiServiceCost$ {
   export type Outbound = CalculateProductionApiServiceCost$Outbound;
 }
 
+export function calculateProductionApiServiceCostToJSON(
+  calculateProductionApiServiceCost: CalculateProductionApiServiceCost,
+): string {
+  return JSON.stringify(
+    CalculateProductionApiServiceCost$outboundSchema.parse(
+      calculateProductionApiServiceCost,
+    ),
+  );
+}
+
+export function calculateProductionApiServiceCostFromJSON(
+  jsonString: string,
+): SafeParseResult<CalculateProductionApiServiceCost, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CalculateProductionApiServiceCost$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CalculateProductionApiServiceCost' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorResponseBody$inboundSchema: z.ZodType<
   PricingCalculatorResponseBody,
@@ -944,6 +1206,26 @@ export namespace PricingCalculatorResponseBody$ {
   export type Outbound = PricingCalculatorResponseBody$Outbound;
 }
 
+export function pricingCalculatorResponseBodyToJSON(
+  pricingCalculatorResponseBody: PricingCalculatorResponseBody,
+): string {
+  return JSON.stringify(
+    PricingCalculatorResponseBody$outboundSchema.parse(
+      pricingCalculatorResponseBody,
+    ),
+  );
+}
+
+export function pricingCalculatorResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PricingCalculatorResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PricingCalculatorResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PricingCalculatorResponse$inboundSchema: z.ZodType<
   PricingCalculatorResponse,
@@ -1002,3 +1284,21 @@ export namespace PricingCalculatorResponse$ {
   /** @deprecated use `PricingCalculatorResponse$Outbound` instead. */
   export type Outbound = PricingCalculatorResponse$Outbound;
 }
+
+export function pricingCalculatorResponseToJSON(
+  pricingCalculatorResponse: PricingCalculatorResponse,
+): string {
+  return JSON.stringify(
+    PricingCalculatorResponse$outboundSchema.parse(pricingCalculatorResponse),
+  );
+}
+
+export function pricingCalculatorResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PricingCalculatorResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PricingCalculatorResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PricingCalculatorResponse' from JSON`,
+  );
+}

package/src/sdk/models/operations/promptimprove.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 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";
 
 /**
  * Query parameters to be provided in the request body as a JSON object
@@ -88,6 +91,24 @@ export namespace PromptImproveRequestBody$ {
   export type Outbound = PromptImproveRequestBody$Outbound;
 }
 
+export function promptImproveRequestBodyToJSON(
+  promptImproveRequestBody: PromptImproveRequestBody,
+): string {
+  return JSON.stringify(
+    PromptImproveRequestBody$outboundSchema.parse(promptImproveRequestBody),
+  );
+}
+
+export function promptImproveRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptImproveRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptImproveRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptImproveRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PromptGenerationOutput$inboundSchema: z.ZodType<
   PromptGenerationOutput,
@@ -127,6 +148,24 @@ export namespace PromptGenerationOutput$ {
   export type Outbound = PromptGenerationOutput$Outbound;
 }
 
+export function promptGenerationOutputToJSON(
+  promptGenerationOutput: PromptGenerationOutput,
+): string {
+  return JSON.stringify(
+    PromptGenerationOutput$outboundSchema.parse(promptGenerationOutput),
+  );
+}
+
+export function promptGenerationOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptGenerationOutput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptGenerationOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptGenerationOutput' from JSON`,
+  );
+}
+
 /** @internal */
 export const PromptImproveResponseBody$inboundSchema: z.ZodType<
   PromptImproveResponseBody,
@@ -165,6 +204,24 @@ export namespace PromptImproveResponseBody$ {
   export type Outbound = PromptImproveResponseBody$Outbound;
 }
 
+export function promptImproveResponseBodyToJSON(
+  promptImproveResponseBody: PromptImproveResponseBody,
+): string {
+  return JSON.stringify(
+    PromptImproveResponseBody$outboundSchema.parse(promptImproveResponseBody),
+  );
+}
+
+export function promptImproveResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptImproveResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptImproveResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptImproveResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PromptImproveResponse$inboundSchema: z.ZodType<
   PromptImproveResponse,
@@ -223,3 +280,21 @@ export namespace PromptImproveResponse$ {
   /** @deprecated use `PromptImproveResponse$Outbound` instead. */
   export type Outbound = PromptImproveResponse$Outbound;
 }
+
+export function promptImproveResponseToJSON(
+  promptImproveResponse: PromptImproveResponse,
+): string {
+  return JSON.stringify(
+    PromptImproveResponse$outboundSchema.parse(promptImproveResponse),
+  );
+}
+
+export function promptImproveResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptImproveResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptImproveResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptImproveResponse' from JSON`,
+  );
+}

package/src/sdk/models/operations/promptrandom.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 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";
 
 export type PromptRandomPromptGenerationOutput = {
   /**
@@ -82,6 +85,27 @@ export namespace PromptRandomPromptGenerationOutput$ {
   export type Outbound = PromptRandomPromptGenerationOutput$Outbound;
 }
 
+export function promptRandomPromptGenerationOutputToJSON(
+  promptRandomPromptGenerationOutput: PromptRandomPromptGenerationOutput,
+): string {
+  return JSON.stringify(
+    PromptRandomPromptGenerationOutput$outboundSchema.parse(
+      promptRandomPromptGenerationOutput,
+    ),
+  );
+}
+
+export function promptRandomPromptGenerationOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptRandomPromptGenerationOutput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PromptRandomPromptGenerationOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptRandomPromptGenerationOutput' from JSON`,
+  );
+}
+
 /** @internal */
 export const PromptRandomResponseBody$inboundSchema: z.ZodType<
   PromptRandomResponseBody,
@@ -122,6 +146,24 @@ export namespace PromptRandomResponseBody$ {
   export type Outbound = PromptRandomResponseBody$Outbound;
 }
 
+export function promptRandomResponseBodyToJSON(
+  promptRandomResponseBody: PromptRandomResponseBody,
+): string {
+  return JSON.stringify(
+    PromptRandomResponseBody$outboundSchema.parse(promptRandomResponseBody),
+  );
+}
+
+export function promptRandomResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptRandomResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptRandomResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptRandomResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PromptRandomResponse$inboundSchema: z.ZodType<
   PromptRandomResponse,
@@ -180,3 +222,21 @@ export namespace PromptRandomResponse$ {
   /** @deprecated use `PromptRandomResponse$Outbound` instead. */
   export type Outbound = PromptRandomResponse$Outbound;
 }
+
+export function promptRandomResponseToJSON(
+  promptRandomResponse: PromptRandomResponse,
+): string {
+  return JSON.stringify(
+    PromptRandomResponse$outboundSchema.parse(promptRandomResponse),
+  );
+}
+
+export function promptRandomResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptRandomResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptRandomResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptRandomResponse' from JSON`,
+  );
+}