@vercel/sdk 14.0.0-canary.5 → 14.0.0-canary.7

package/src/models/operations/createedgeconfig.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Two5 = {};
 
@@ -115,6 +118,20 @@ export namespace Two5$ {
   export type Outbound = Two5$Outbound;
 }
 
+export function two5ToJSON(two5: Two5): string {
+  return JSON.stringify(Two5$outboundSchema.parse(two5));
+}
+
+export function two5FromJSON(
+  jsonString: string,
+): SafeParseResult<Two5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two5' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items2$inboundSchema: z.ZodType<Items2, z.ZodTypeDef, unknown> = z
   .union([
@@ -154,6 +171,20 @@ export namespace Items2$ {
   export type Outbound = Items2$Outbound;
 }
 
+export function items2ToJSON(items2: Items2): string {
+  return JSON.stringify(Items2$outboundSchema.parse(items2));
+}
+
+export function items2FromJSON(
+  jsonString: string,
+): SafeParseResult<Items2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items2' from JSON`,
+  );
+}
+
 /** @internal */
 export const One5$inboundSchema: z.ZodType<One5, z.ZodTypeDef, unknown> = z
   .object({});
@@ -178,6 +209,20 @@ export namespace One5$ {
   export type Outbound = One5$Outbound;
 }
 
+export function one5ToJSON(one5: One5): string {
+  return JSON.stringify(One5$outboundSchema.parse(one5));
+}
+
+export function one5FromJSON(
+  jsonString: string,
+): SafeParseResult<One5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One5' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items1$inboundSchema: z.ZodType<Items1, z.ZodTypeDef, unknown> = z
   .union([
@@ -217,6 +262,20 @@ export namespace Items1$ {
   export type Outbound = Items1$Outbound;
 }
 
+export function items1ToJSON(items1: Items1): string {
+  return JSON.stringify(Items1$outboundSchema.parse(items1));
+}
+
+export function items1FromJSON(
+  jsonString: string,
+): SafeParseResult<Items1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items$inboundSchema: z.ZodType<Items, z.ZodTypeDef, unknown> = z
   .union([
@@ -284,6 +343,20 @@ export namespace Items$ {
   export type Outbound = Items$Outbound;
 }
 
+export function itemsToJSON(items: Items): string {
+  return JSON.stringify(Items$outboundSchema.parse(items));
+}
+
+export function itemsFromJSON(
+  jsonString: string,
+): SafeParseResult<Items, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigRequestBody$inboundSchema: z.ZodType<
   CreateEdgeConfigRequestBody,
@@ -369,6 +442,26 @@ export namespace CreateEdgeConfigRequestBody$ {
   export type Outbound = CreateEdgeConfigRequestBody$Outbound;
 }
 
+export function createEdgeConfigRequestBodyToJSON(
+  createEdgeConfigRequestBody: CreateEdgeConfigRequestBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigRequestBody$outboundSchema.parse(
+      createEdgeConfigRequestBody,
+    ),
+  );
+}
+
+export function createEdgeConfigRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigRequest$inboundSchema: z.ZodType<
   CreateEdgeConfigRequest,
@@ -421,6 +514,24 @@ export namespace CreateEdgeConfigRequest$ {
   export type Outbound = CreateEdgeConfigRequest$Outbound;
 }
 
+export function createEdgeConfigRequestToJSON(
+  createEdgeConfigRequest: CreateEdgeConfigRequest,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigRequest$outboundSchema.parse(createEdgeConfigRequest),
+  );
+}
+
+export function createEdgeConfigRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTransfer$inboundSchema: z.ZodType<
   CreateEdgeConfigTransfer,
@@ -463,6 +574,24 @@ export namespace CreateEdgeConfigTransfer$ {
   export type Outbound = CreateEdgeConfigTransfer$Outbound;
 }
 
+export function createEdgeConfigTransferToJSON(
+  createEdgeConfigTransfer: CreateEdgeConfigTransfer,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTransfer$outboundSchema.parse(createEdgeConfigTransfer),
+  );
+}
+
+export function createEdgeConfigTransferFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTransfer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTransfer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTransfer' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigSchema$inboundSchema: z.ZodType<
   CreateEdgeConfigSchema,
@@ -493,6 +622,24 @@ export namespace CreateEdgeConfigSchema$ {
   export type Outbound = CreateEdgeConfigSchema$Outbound;
 }
 
+export function createEdgeConfigSchemaToJSON(
+  createEdgeConfigSchema: CreateEdgeConfigSchema,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigSchema$outboundSchema.parse(createEdgeConfigSchema),
+  );
+}
+
+export function createEdgeConfigSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigType$inboundSchema: z.ZodNativeEnum<
   typeof CreateEdgeConfigType
@@ -553,6 +700,24 @@ export namespace CreateEdgeConfigPurpose$ {
   export type Outbound = CreateEdgeConfigPurpose$Outbound;
 }
 
+export function createEdgeConfigPurposeToJSON(
+  createEdgeConfigPurpose: CreateEdgeConfigPurpose,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigPurpose$outboundSchema.parse(createEdgeConfigPurpose),
+  );
+}
+
+export function createEdgeConfigPurposeFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigPurpose, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigPurpose$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigPurpose' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigResponseBody$inboundSchema: z.ZodType<
   CreateEdgeConfigResponseBody,
@@ -618,3 +783,23 @@ export namespace CreateEdgeConfigResponseBody$ {
   /** @deprecated use `CreateEdgeConfigResponseBody$Outbound` instead. */
   export type Outbound = CreateEdgeConfigResponseBody$Outbound;
 }
+
+export function createEdgeConfigResponseBodyToJSON(
+  createEdgeConfigResponseBody: CreateEdgeConfigResponseBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigResponseBody$outboundSchema.parse(
+      createEdgeConfigResponseBody,
+    ),
+  );
+}
+
+export function createEdgeConfigResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigResponseBody' from JSON`,
+  );
+}

package/src/models/operations/createedgeconfigtoken.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 CreateEdgeConfigTokenRequestBody = {
   label: string;
@@ -63,6 +66,26 @@ export namespace CreateEdgeConfigTokenRequestBody$ {
   export type Outbound = CreateEdgeConfigTokenRequestBody$Outbound;
 }
 
+export function createEdgeConfigTokenRequestBodyToJSON(
+  createEdgeConfigTokenRequestBody: CreateEdgeConfigTokenRequestBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenRequestBody$outboundSchema.parse(
+      createEdgeConfigTokenRequestBody,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTokenRequest$inboundSchema: z.ZodType<
   CreateEdgeConfigTokenRequest,
@@ -118,6 +141,26 @@ export namespace CreateEdgeConfigTokenRequest$ {
   export type Outbound = CreateEdgeConfigTokenRequest$Outbound;
 }
 
+export function createEdgeConfigTokenRequestToJSON(
+  createEdgeConfigTokenRequest: CreateEdgeConfigTokenRequest,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenRequest$outboundSchema.parse(
+      createEdgeConfigTokenRequest,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTokenResponseBody$inboundSchema: z.ZodType<
   CreateEdgeConfigTokenResponseBody,
@@ -157,3 +200,23 @@ export namespace CreateEdgeConfigTokenResponseBody$ {
   /** @deprecated use `CreateEdgeConfigTokenResponseBody$Outbound` instead. */
   export type Outbound = CreateEdgeConfigTokenResponseBody$Outbound;
 }
+
+export function createEdgeConfigTokenResponseBodyToJSON(
+  createEdgeConfigTokenResponseBody: CreateEdgeConfigTokenResponseBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenResponseBody$outboundSchema.parse(
+      createEdgeConfigTokenResponseBody,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenResponseBody' from JSON`,
+  );
+}

package/src/models/operations/createlogdrain.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 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";
 
 /**
  * The delivery log format
@@ -315,6 +318,24 @@ export namespace CreateLogDrainRequestBody$ {
   export type Outbound = CreateLogDrainRequestBody$Outbound;
 }
 
+export function createLogDrainRequestBodyToJSON(
+  createLogDrainRequestBody: CreateLogDrainRequestBody,
+): string {
+  return JSON.stringify(
+    CreateLogDrainRequestBody$outboundSchema.parse(createLogDrainRequestBody),
+  );
+}
+
+export function createLogDrainRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateLogDrainRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateLogDrainRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateLogDrainRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateLogDrainRequest$inboundSchema: z.ZodType<
   CreateLogDrainRequest,
@@ -366,6 +387,24 @@ export namespace CreateLogDrainRequest$ {
   export type Outbound = CreateLogDrainRequest$Outbound;
 }
 
+export function createLogDrainRequestToJSON(
+  createLogDrainRequest: CreateLogDrainRequest,
+): string {
+  return JSON.stringify(
+    CreateLogDrainRequest$outboundSchema.parse(createLogDrainRequest),
+  );
+}
+
+export function createLogDrainRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateLogDrainRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateLogDrainRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateLogDrainRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateLogDrainDeliveryFormat$inboundSchema: z.ZodNativeEnum<
   typeof CreateLogDrainDeliveryFormat
@@ -530,3 +569,21 @@ export namespace CreateLogDrainResponseBody$ {
   /** @deprecated use `CreateLogDrainResponseBody$Outbound` instead. */
   export type Outbound = CreateLogDrainResponseBody$Outbound;
 }
+
+export function createLogDrainResponseBodyToJSON(
+  createLogDrainResponseBody: CreateLogDrainResponseBody,
+): string {
+  return JSON.stringify(
+    CreateLogDrainResponseBody$outboundSchema.parse(createLogDrainResponseBody),
+  );
+}
+
+export function createLogDrainResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateLogDrainResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateLogDrainResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateLogDrainResponseBody' from JSON`,
+  );
+}

package/src/models/operations/createortransferdomain.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 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";
 
 /**
  * transfer-in
@@ -227,6 +230,27 @@ export namespace CreateOrTransferDomainRequestBody3$ {
   export type Outbound = CreateOrTransferDomainRequestBody3$Outbound;
 }
 
+export function createOrTransferDomainRequestBody3ToJSON(
+  createOrTransferDomainRequestBody3: CreateOrTransferDomainRequestBody3,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainRequestBody3$outboundSchema.parse(
+      createOrTransferDomainRequestBody3,
+    ),
+  );
+}
+
+export function createOrTransferDomainRequestBody3FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainRequestBody3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateOrTransferDomainRequestBody3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainRequestBody3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainRequestBody2$inboundSchema: z.ZodType<
   CreateOrTransferDomainRequestBody2,
@@ -270,6 +294,27 @@ export namespace CreateOrTransferDomainRequestBody2$ {
   export type Outbound = CreateOrTransferDomainRequestBody2$Outbound;
 }
 
+export function createOrTransferDomainRequestBody2ToJSON(
+  createOrTransferDomainRequestBody2: CreateOrTransferDomainRequestBody2,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainRequestBody2$outboundSchema.parse(
+      createOrTransferDomainRequestBody2,
+    ),
+  );
+}
+
+export function createOrTransferDomainRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateOrTransferDomainRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainRequestBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainRequestBody1$inboundSchema: z.ZodType<
   CreateOrTransferDomainRequestBody1,
@@ -316,6 +361,27 @@ export namespace CreateOrTransferDomainRequestBody1$ {
   export type Outbound = CreateOrTransferDomainRequestBody1$Outbound;
 }
 
+export function createOrTransferDomainRequestBody1ToJSON(
+  createOrTransferDomainRequestBody1: CreateOrTransferDomainRequestBody1,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainRequestBody1$outboundSchema.parse(
+      createOrTransferDomainRequestBody1,
+    ),
+  );
+}
+
+export function createOrTransferDomainRequestBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainRequestBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateOrTransferDomainRequestBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainRequestBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainRequestBody$inboundSchema: z.ZodType<
   CreateOrTransferDomainRequestBody,
@@ -358,6 +424,26 @@ export namespace CreateOrTransferDomainRequestBody$ {
   export type Outbound = CreateOrTransferDomainRequestBody$Outbound;
 }
 
+export function createOrTransferDomainRequestBodyToJSON(
+  createOrTransferDomainRequestBody: CreateOrTransferDomainRequestBody,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainRequestBody$outboundSchema.parse(
+      createOrTransferDomainRequestBody,
+    ),
+  );
+}
+
+export function createOrTransferDomainRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateOrTransferDomainRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainRequest$inboundSchema: z.ZodType<
   CreateOrTransferDomainRequest,
@@ -420,6 +506,26 @@ export namespace CreateOrTransferDomainRequest$ {
   export type Outbound = CreateOrTransferDomainRequest$Outbound;
 }
 
+export function createOrTransferDomainRequestToJSON(
+  createOrTransferDomainRequest: CreateOrTransferDomainRequest,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainRequest$outboundSchema.parse(
+      createOrTransferDomainRequest,
+    ),
+  );
+}
+
+export function createOrTransferDomainRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateOrTransferDomainRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainCreator$inboundSchema: z.ZodType<
   CreateOrTransferDomainCreator,
@@ -468,6 +574,26 @@ export namespace CreateOrTransferDomainCreator$ {
   export type Outbound = CreateOrTransferDomainCreator$Outbound;
 }
 
+export function createOrTransferDomainCreatorToJSON(
+  createOrTransferDomainCreator: CreateOrTransferDomainCreator,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainCreator$outboundSchema.parse(
+      createOrTransferDomainCreator,
+    ),
+  );
+}
+
+export function createOrTransferDomainCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateOrTransferDomainCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainServiceType$inboundSchema: z.ZodNativeEnum<
   typeof CreateOrTransferDomainServiceType
@@ -574,6 +700,26 @@ export namespace CreateOrTransferDomainDomain$ {
   export type Outbound = CreateOrTransferDomainDomain$Outbound;
 }
 
+export function createOrTransferDomainDomainToJSON(
+  createOrTransferDomainDomain: CreateOrTransferDomainDomain,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainDomain$outboundSchema.parse(
+      createOrTransferDomainDomain,
+    ),
+  );
+}
+
+export function createOrTransferDomainDomainFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainDomain, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateOrTransferDomainDomain$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainDomain' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateOrTransferDomainResponseBody$inboundSchema: z.ZodType<
   CreateOrTransferDomainResponseBody,
@@ -610,3 +756,24 @@ export namespace CreateOrTransferDomainResponseBody$ {
   /** @deprecated use `CreateOrTransferDomainResponseBody$Outbound` instead. */
   export type Outbound = CreateOrTransferDomainResponseBody$Outbound;
 }
+
+export function createOrTransferDomainResponseBodyToJSON(
+  createOrTransferDomainResponseBody: CreateOrTransferDomainResponseBody,
+): string {
+  return JSON.stringify(
+    CreateOrTransferDomainResponseBody$outboundSchema.parse(
+      createOrTransferDomainResponseBody,
+    ),
+  );
+}
+
+export function createOrTransferDomainResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateOrTransferDomainResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateOrTransferDomainResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateOrTransferDomainResponseBody' from JSON`,
+  );
+}