@vercel/sdk 14.0.0-canary.6 → 14.0.0-canary.9

package/src/models/operations/listauthtokens.ts

@@ -3,6 +3,8 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import {
   AuthToken,
   AuthToken$inboundSchema,
@@ -15,6 +17,7 @@ import {
   Pagination$Outbound,
   Pagination$outboundSchema,
 } from "../components/pagination.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListAuthTokensResponseBody = {
   tokens: Array<AuthToken>;
@@ -69,3 +72,21 @@ export namespace ListAuthTokensResponseBody$ {
   /** @deprecated use `ListAuthTokensResponseBody$Outbound` instead. */
   export type Outbound = ListAuthTokensResponseBody$Outbound;
 }
+
+export function listAuthTokensResponseBodyToJSON(
+  listAuthTokensResponseBody: ListAuthTokensResponseBody,
+): string {
+  return JSON.stringify(
+    ListAuthTokensResponseBody$outboundSchema.parse(listAuthTokensResponseBody),
+  );
+}
+
+export function listAuthTokensResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAuthTokensResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAuthTokensResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAuthTokensResponseBody' from JSON`,
+  );
+}

package/src/models/operations/listdeploymentaliases.ts

@@ -3,7 +3,10 @@
  */
 
 import * as z from "zod";
+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 ListDeploymentAliasesRequest = {
   /**
@@ -185,6 +188,26 @@ export namespace ListDeploymentAliasesRequest$ {
   export type Outbound = ListDeploymentAliasesRequest$Outbound;
 }
 
+export function listDeploymentAliasesRequestToJSON(
+  listDeploymentAliasesRequest: ListDeploymentAliasesRequest,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesRequest$outboundSchema.parse(
+      listDeploymentAliasesRequest,
+    ),
+  );
+}
+
+export function listDeploymentAliasesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDeploymentAliasesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesProtectionBypassAliasesResponse200Scope$inboundSchema:
   z.ZodNativeEnum<
@@ -262,6 +285,28 @@ export namespace ListDeploymentAliasesProtectionBypass4$ {
   export type Outbound = ListDeploymentAliasesProtectionBypass4$Outbound;
 }
 
+export function listDeploymentAliasesProtectionBypass4ToJSON(
+  listDeploymentAliasesProtectionBypass4:
+    ListDeploymentAliasesProtectionBypass4,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesProtectionBypass4$outboundSchema.parse(
+      listDeploymentAliasesProtectionBypass4,
+    ),
+  );
+}
+
+export function listDeploymentAliasesProtectionBypass4FromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesProtectionBypass4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListDeploymentAliasesProtectionBypass4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesProtectionBypass4' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesProtectionBypassAliasesResponseScope$inboundSchema:
   z.ZodNativeEnum<
@@ -333,6 +378,28 @@ export namespace ListDeploymentAliasesProtectionBypass3$ {
   export type Outbound = ListDeploymentAliasesProtectionBypass3$Outbound;
 }
 
+export function listDeploymentAliasesProtectionBypass3ToJSON(
+  listDeploymentAliasesProtectionBypass3:
+    ListDeploymentAliasesProtectionBypass3,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesProtectionBypass3$outboundSchema.parse(
+      listDeploymentAliasesProtectionBypass3,
+    ),
+  );
+}
+
+export function listDeploymentAliasesProtectionBypass3FromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesProtectionBypass3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListDeploymentAliasesProtectionBypass3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesProtectionBypass3' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesProtectionBypassAccess$inboundSchema:
   z.ZodNativeEnum<typeof ListDeploymentAliasesProtectionBypassAccess> = z
@@ -429,6 +496,28 @@ export namespace ListDeploymentAliasesProtectionBypass2$ {
   export type Outbound = ListDeploymentAliasesProtectionBypass2$Outbound;
 }
 
+export function listDeploymentAliasesProtectionBypass2ToJSON(
+  listDeploymentAliasesProtectionBypass2:
+    ListDeploymentAliasesProtectionBypass2,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesProtectionBypass2$outboundSchema.parse(
+      listDeploymentAliasesProtectionBypass2,
+    ),
+  );
+}
+
+export function listDeploymentAliasesProtectionBypass2FromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesProtectionBypass2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListDeploymentAliasesProtectionBypass2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesProtectionBypass2' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesProtectionBypassScope$inboundSchema:
   z.ZodNativeEnum<typeof ListDeploymentAliasesProtectionBypassScope> = z
@@ -496,6 +585,28 @@ export namespace ListDeploymentAliasesProtectionBypass1$ {
   export type Outbound = ListDeploymentAliasesProtectionBypass1$Outbound;
 }
 
+export function listDeploymentAliasesProtectionBypass1ToJSON(
+  listDeploymentAliasesProtectionBypass1:
+    ListDeploymentAliasesProtectionBypass1,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesProtectionBypass1$outboundSchema.parse(
+      listDeploymentAliasesProtectionBypass1,
+    ),
+  );
+}
+
+export function listDeploymentAliasesProtectionBypass1FromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesProtectionBypass1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListDeploymentAliasesProtectionBypass1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesProtectionBypass1' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesProtectionBypass$inboundSchema: z.ZodType<
   ListDeploymentAliasesProtectionBypass,
@@ -542,6 +653,27 @@ export namespace ListDeploymentAliasesProtectionBypass$ {
   export type Outbound = ListDeploymentAliasesProtectionBypass$Outbound;
 }
 
+export function listDeploymentAliasesProtectionBypassToJSON(
+  listDeploymentAliasesProtectionBypass: ListDeploymentAliasesProtectionBypass,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesProtectionBypass$outboundSchema.parse(
+      listDeploymentAliasesProtectionBypass,
+    ),
+  );
+}
+
+export function listDeploymentAliasesProtectionBypassFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesProtectionBypass, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListDeploymentAliasesProtectionBypass$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesProtectionBypass' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesAliases$inboundSchema: z.ZodType<
   ListDeploymentAliasesAliases,
@@ -610,6 +742,26 @@ export namespace ListDeploymentAliasesAliases$ {
   export type Outbound = ListDeploymentAliasesAliases$Outbound;
 }
 
+export function listDeploymentAliasesAliasesToJSON(
+  listDeploymentAliasesAliases: ListDeploymentAliasesAliases,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesAliases$outboundSchema.parse(
+      listDeploymentAliasesAliases,
+    ),
+  );
+}
+
+export function listDeploymentAliasesAliasesFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesAliases, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDeploymentAliasesAliases$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesAliases' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListDeploymentAliasesResponseBody$inboundSchema: z.ZodType<
   ListDeploymentAliasesResponseBody,
@@ -646,3 +798,23 @@ export namespace ListDeploymentAliasesResponseBody$ {
   /** @deprecated use `ListDeploymentAliasesResponseBody$Outbound` instead. */
   export type Outbound = ListDeploymentAliasesResponseBody$Outbound;
 }
+
+export function listDeploymentAliasesResponseBodyToJSON(
+  listDeploymentAliasesResponseBody: ListDeploymentAliasesResponseBody,
+): string {
+  return JSON.stringify(
+    ListDeploymentAliasesResponseBody$outboundSchema.parse(
+      listDeploymentAliasesResponseBody,
+    ),
+  );
+}
+
+export function listDeploymentAliasesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentAliasesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDeploymentAliasesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentAliasesResponseBody' from JSON`,
+  );
+}

package/src/models/operations/listdeploymentfiles.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListDeploymentFilesRequest = {
   /**
@@ -60,3 +63,21 @@ export namespace ListDeploymentFilesRequest$ {
   /** @deprecated use `ListDeploymentFilesRequest$Outbound` instead. */
   export type Outbound = ListDeploymentFilesRequest$Outbound;
 }
+
+export function listDeploymentFilesRequestToJSON(
+  listDeploymentFilesRequest: ListDeploymentFilesRequest,
+): string {
+  return JSON.stringify(
+    ListDeploymentFilesRequest$outboundSchema.parse(listDeploymentFilesRequest),
+  );
+}
+
+export function listDeploymentFilesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDeploymentFilesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDeploymentFilesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDeploymentFilesRequest' from JSON`,
+  );
+}

package/src/models/operations/listpromotealiases.ts

@@ -3,12 +3,15 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import {
   Pagination,
   Pagination$inboundSchema,
   Pagination$Outbound,
   Pagination$outboundSchema,
 } from "../components/pagination.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListPromoteAliasesRequest = {
   projectId: string;
@@ -112,6 +115,24 @@ export namespace ListPromoteAliasesRequest$ {
   export type Outbound = ListPromoteAliasesRequest$Outbound;
 }
 
+export function listPromoteAliasesRequestToJSON(
+  listPromoteAliasesRequest: ListPromoteAliasesRequest,
+): string {
+  return JSON.stringify(
+    ListPromoteAliasesRequest$outboundSchema.parse(listPromoteAliasesRequest),
+  );
+}
+
+export function listPromoteAliasesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ListPromoteAliasesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListPromoteAliasesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListPromoteAliasesRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBodyAliases$inboundSchema: z.ZodType<
   ResponseBodyAliases,
@@ -154,6 +175,24 @@ export namespace ResponseBodyAliases$ {
   export type Outbound = ResponseBodyAliases$Outbound;
 }
 
+export function responseBodyAliasesToJSON(
+  responseBodyAliases: ResponseBodyAliases,
+): string {
+  return JSON.stringify(
+    ResponseBodyAliases$outboundSchema.parse(responseBodyAliases),
+  );
+}
+
+export function responseBodyAliasesFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyAliases, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyAliases$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyAliases' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListPromoteAliasesResponseBody2$inboundSchema: z.ZodType<
   ListPromoteAliasesResponseBody2,
@@ -193,6 +232,26 @@ export namespace ListPromoteAliasesResponseBody2$ {
   export type Outbound = ListPromoteAliasesResponseBody2$Outbound;
 }
 
+export function listPromoteAliasesResponseBody2ToJSON(
+  listPromoteAliasesResponseBody2: ListPromoteAliasesResponseBody2,
+): string {
+  return JSON.stringify(
+    ListPromoteAliasesResponseBody2$outboundSchema.parse(
+      listPromoteAliasesResponseBody2,
+    ),
+  );
+}
+
+export function listPromoteAliasesResponseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<ListPromoteAliasesResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListPromoteAliasesResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListPromoteAliasesResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListPromoteAliasesResponseBody1$inboundSchema: z.ZodType<
   ListPromoteAliasesResponseBody1,
@@ -223,6 +282,26 @@ export namespace ListPromoteAliasesResponseBody1$ {
   export type Outbound = ListPromoteAliasesResponseBody1$Outbound;
 }
 
+export function listPromoteAliasesResponseBody1ToJSON(
+  listPromoteAliasesResponseBody1: ListPromoteAliasesResponseBody1,
+): string {
+  return JSON.stringify(
+    ListPromoteAliasesResponseBody1$outboundSchema.parse(
+      listPromoteAliasesResponseBody1,
+    ),
+  );
+}
+
+export function listPromoteAliasesResponseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<ListPromoteAliasesResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListPromoteAliasesResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListPromoteAliasesResponseBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListPromoteAliasesResponseBody$inboundSchema: z.ZodType<
   ListPromoteAliasesResponseBody,
@@ -260,3 +339,23 @@ export namespace ListPromoteAliasesResponseBody$ {
   /** @deprecated use `ListPromoteAliasesResponseBody$Outbound` instead. */
   export type Outbound = ListPromoteAliasesResponseBody$Outbound;
 }
+
+export function listPromoteAliasesResponseBodyToJSON(
+  listPromoteAliasesResponseBody: ListPromoteAliasesResponseBody,
+): string {
+  return JSON.stringify(
+    ListPromoteAliasesResponseBody$outboundSchema.parse(
+      listPromoteAliasesResponseBody,
+    ),
+  );
+}
+
+export function listPromoteAliasesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListPromoteAliasesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListPromoteAliasesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListPromoteAliasesResponseBody' from JSON`,
+  );
+}

package/src/models/operations/listuserevents.ts

@@ -3,12 +3,15 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import {
   UserEvent,
   UserEvent$inboundSchema,
   UserEvent$Outbound,
   UserEvent$outboundSchema,
 } from "../components/userevent.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListUserEventsRequest = {
   /**
@@ -112,6 +115,24 @@ export namespace ListUserEventsRequest$ {
   export type Outbound = ListUserEventsRequest$Outbound;
 }
 
+export function listUserEventsRequestToJSON(
+  listUserEventsRequest: ListUserEventsRequest,
+): string {
+  return JSON.stringify(
+    ListUserEventsRequest$outboundSchema.parse(listUserEventsRequest),
+  );
+}
+
+export function listUserEventsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ListUserEventsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListUserEventsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListUserEventsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListUserEventsResponseBody$inboundSchema: z.ZodType<
   ListUserEventsResponseBody,
@@ -147,3 +168,21 @@ export namespace ListUserEventsResponseBody$ {
   /** @deprecated use `ListUserEventsResponseBody$Outbound` instead. */
   export type Outbound = ListUserEventsResponseBody$Outbound;
 }
+
+export function listUserEventsResponseBodyToJSON(
+  listUserEventsResponseBody: ListUserEventsResponseBody,
+): string {
+  return JSON.stringify(
+    ListUserEventsResponseBody$outboundSchema.parse(listUserEventsResponseBody),
+  );
+}
+
+export function listUserEventsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListUserEventsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListUserEventsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListUserEventsResponseBody' from JSON`,
+  );
+}

package/src/models/operations/patchdomain.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";
 
 /**
  * move-out
@@ -111,6 +114,24 @@ export namespace PatchDomainRequestBody2$ {
   export type Outbound = PatchDomainRequestBody2$Outbound;
 }
 
+export function patchDomainRequestBody2ToJSON(
+  patchDomainRequestBody2: PatchDomainRequestBody2,
+): string {
+  return JSON.stringify(
+    PatchDomainRequestBody2$outboundSchema.parse(patchDomainRequestBody2),
+  );
+}
+
+export function patchDomainRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainRequestBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainRequestBody1$inboundSchema: z.ZodType<
   PatchDomainRequestBody1,
@@ -156,6 +177,24 @@ export namespace PatchDomainRequestBody1$ {
   export type Outbound = PatchDomainRequestBody1$Outbound;
 }
 
+export function patchDomainRequestBody1ToJSON(
+  patchDomainRequestBody1: PatchDomainRequestBody1,
+): string {
+  return JSON.stringify(
+    PatchDomainRequestBody1$outboundSchema.parse(patchDomainRequestBody1),
+  );
+}
+
+export function patchDomainRequestBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainRequestBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainRequestBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainRequestBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainRequestBody$inboundSchema: z.ZodType<
   PatchDomainRequestBody,
@@ -194,6 +233,24 @@ export namespace PatchDomainRequestBody$ {
   export type Outbound = PatchDomainRequestBody$Outbound;
 }
 
+export function patchDomainRequestBodyToJSON(
+  patchDomainRequestBody: PatchDomainRequestBody,
+): string {
+  return JSON.stringify(
+    PatchDomainRequestBody$outboundSchema.parse(patchDomainRequestBody),
+  );
+}
+
+export function patchDomainRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainRequest$inboundSchema: z.ZodType<
   PatchDomainRequest,
@@ -256,6 +313,24 @@ export namespace PatchDomainRequest$ {
   export type Outbound = PatchDomainRequest$Outbound;
 }
 
+export function patchDomainRequestToJSON(
+  patchDomainRequest: PatchDomainRequest,
+): string {
+  return JSON.stringify(
+    PatchDomainRequest$outboundSchema.parse(patchDomainRequest),
+  );
+}
+
+export function patchDomainRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainResponseBody3$inboundSchema: z.ZodType<
   PatchDomainResponseBody3,
@@ -298,6 +373,24 @@ export namespace PatchDomainResponseBody3$ {
   export type Outbound = PatchDomainResponseBody3$Outbound;
 }
 
+export function patchDomainResponseBody3ToJSON(
+  patchDomainResponseBody3: PatchDomainResponseBody3,
+): string {
+  return JSON.stringify(
+    PatchDomainResponseBody3$outboundSchema.parse(patchDomainResponseBody3),
+  );
+}
+
+export function patchDomainResponseBody3FromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainResponseBody3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainResponseBody3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainResponseBody3' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainResponseBody2$inboundSchema: z.ZodType<
   PatchDomainResponseBody2,
@@ -337,6 +430,24 @@ export namespace PatchDomainResponseBody2$ {
   export type Outbound = PatchDomainResponseBody2$Outbound;
 }
 
+export function patchDomainResponseBody2ToJSON(
+  patchDomainResponseBody2: PatchDomainResponseBody2,
+): string {
+  return JSON.stringify(
+    PatchDomainResponseBody2$outboundSchema.parse(patchDomainResponseBody2),
+  );
+}
+
+export function patchDomainResponseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainResponseBody1$inboundSchema: z.ZodType<
   PatchDomainResponseBody1,
@@ -373,6 +484,24 @@ export namespace PatchDomainResponseBody1$ {
   export type Outbound = PatchDomainResponseBody1$Outbound;
 }
 
+export function patchDomainResponseBody1ToJSON(
+  patchDomainResponseBody1: PatchDomainResponseBody1,
+): string {
+  return JSON.stringify(
+    PatchDomainResponseBody1$outboundSchema.parse(patchDomainResponseBody1),
+  );
+}
+
+export function patchDomainResponseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainResponseBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const PatchDomainResponseBody$inboundSchema: z.ZodType<
   PatchDomainResponseBody,
@@ -413,3 +542,21 @@ export namespace PatchDomainResponseBody$ {
   /** @deprecated use `PatchDomainResponseBody$Outbound` instead. */
   export type Outbound = PatchDomainResponseBody$Outbound;
 }
+
+export function patchDomainResponseBodyToJSON(
+  patchDomainResponseBody: PatchDomainResponseBody,
+): string {
+  return JSON.stringify(
+    PatchDomainResponseBody$outboundSchema.parse(patchDomainResponseBody),
+  );
+}
+
+export function patchDomainResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDomainResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDomainResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDomainResponseBody' from JSON`,
+  );
+}