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

package/src/models/operations/updateprojectdomain.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";
 
 /**
  * Status code for domain redirect
@@ -151,6 +154,26 @@ export namespace UpdateProjectDomainRequestBody$ {
   export type Outbound = UpdateProjectDomainRequestBody$Outbound;
 }
 
+export function updateProjectDomainRequestBodyToJSON(
+  updateProjectDomainRequestBody: UpdateProjectDomainRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectDomainRequestBody$outboundSchema.parse(
+      updateProjectDomainRequestBody,
+    ),
+  );
+}
+
+export function updateProjectDomainRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDomainRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDomainRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDomainRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDomainRequest$inboundSchema: z.ZodType<
   UpdateProjectDomainRequest,
@@ -209,6 +232,24 @@ export namespace UpdateProjectDomainRequest$ {
   export type Outbound = UpdateProjectDomainRequest$Outbound;
 }
 
+export function updateProjectDomainRequestToJSON(
+  updateProjectDomainRequest: UpdateProjectDomainRequest,
+): string {
+  return JSON.stringify(
+    UpdateProjectDomainRequest$outboundSchema.parse(updateProjectDomainRequest),
+  );
+}
+
+export function updateProjectDomainRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDomainRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDomainRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDomainRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDomainVerification$inboundSchema: z.ZodType<
   UpdateProjectDomainVerification,
@@ -254,6 +295,26 @@ export namespace UpdateProjectDomainVerification$ {
   export type Outbound = UpdateProjectDomainVerification$Outbound;
 }
 
+export function updateProjectDomainVerificationToJSON(
+  updateProjectDomainVerification: UpdateProjectDomainVerification,
+): string {
+  return JSON.stringify(
+    UpdateProjectDomainVerification$outboundSchema.parse(
+      updateProjectDomainVerification,
+    ),
+  );
+}
+
+export function updateProjectDomainVerificationFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDomainVerification, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDomainVerification$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDomainVerification' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDomainResponseBody$inboundSchema: z.ZodType<
   UpdateProjectDomainResponseBody,
@@ -323,3 +384,23 @@ export namespace UpdateProjectDomainResponseBody$ {
   /** @deprecated use `UpdateProjectDomainResponseBody$Outbound` instead. */
   export type Outbound = UpdateProjectDomainResponseBody$Outbound;
 }
+
+export function updateProjectDomainResponseBodyToJSON(
+  updateProjectDomainResponseBody: UpdateProjectDomainResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectDomainResponseBody$outboundSchema.parse(
+      updateProjectDomainResponseBody,
+    ),
+  );
+}
+
+export function updateProjectDomainResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDomainResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDomainResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDomainResponseBody' from JSON`,
+  );
+}

package/src/models/operations/updateprojectprotectionbypass.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";
 
 /**
  * Optional instructions for revoking and regenerating a automation bypass
@@ -112,6 +115,20 @@ export namespace Revoke$ {
   export type Outbound = Revoke$Outbound;
 }
 
+export function revokeToJSON(revoke: Revoke): string {
+  return JSON.stringify(Revoke$outboundSchema.parse(revoke));
+}
+
+export function revokeFromJSON(
+  jsonString: string,
+): SafeParseResult<Revoke, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Revoke$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Revoke' from JSON`,
+  );
+}
+
 /** @internal */
 export const Generate$inboundSchema: z.ZodType<
   Generate,
@@ -148,6 +165,20 @@ export namespace Generate$ {
   export type Outbound = Generate$Outbound;
 }
 
+export function generateToJSON(generate: Generate): string {
+  return JSON.stringify(Generate$outboundSchema.parse(generate));
+}
+
+export function generateFromJSON(
+  jsonString: string,
+): SafeParseResult<Generate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Generate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Generate' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProtectionBypassRequestBody$inboundSchema: z.ZodType<
   UpdateProjectProtectionBypassRequestBody,
@@ -189,6 +220,33 @@ export namespace UpdateProjectProtectionBypassRequestBody$ {
   export type Outbound = UpdateProjectProtectionBypassRequestBody$Outbound;
 }
 
+export function updateProjectProtectionBypassRequestBodyToJSON(
+  updateProjectProtectionBypassRequestBody:
+    UpdateProjectProtectionBypassRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectProtectionBypassRequestBody$outboundSchema.parse(
+      updateProjectProtectionBypassRequestBody,
+    ),
+  );
+}
+
+export function updateProjectProtectionBypassRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectProtectionBypassRequestBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProtectionBypassRequestBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectProtectionBypassRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProtectionBypassRequest$inboundSchema: z.ZodType<
   UpdateProjectProtectionBypassRequest,
@@ -248,6 +306,27 @@ export namespace UpdateProjectProtectionBypassRequest$ {
   export type Outbound = UpdateProjectProtectionBypassRequest$Outbound;
 }
 
+export function updateProjectProtectionBypassRequestToJSON(
+  updateProjectProtectionBypassRequest: UpdateProjectProtectionBypassRequest,
+): string {
+  return JSON.stringify(
+    UpdateProjectProtectionBypassRequest$outboundSchema.parse(
+      updateProjectProtectionBypassRequest,
+    ),
+  );
+}
+
+export function updateProjectProtectionBypassRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProtectionBypassRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProtectionBypassRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProtectionBypassRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProtectionBypassScope$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProtectionBypassScope
@@ -316,6 +395,33 @@ export namespace UpdateProjectProtectionBypassProtectionBypass$ {
   export type Outbound = UpdateProjectProtectionBypassProtectionBypass$Outbound;
 }
 
+export function updateProjectProtectionBypassProtectionBypassToJSON(
+  updateProjectProtectionBypassProtectionBypass:
+    UpdateProjectProtectionBypassProtectionBypass,
+): string {
+  return JSON.stringify(
+    UpdateProjectProtectionBypassProtectionBypass$outboundSchema.parse(
+      updateProjectProtectionBypassProtectionBypass,
+    ),
+  );
+}
+
+export function updateProjectProtectionBypassProtectionBypassFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectProtectionBypassProtectionBypass,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProtectionBypassProtectionBypass$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectProtectionBypassProtectionBypass' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProtectionBypassResponseBody$inboundSchema: z.ZodType<
   UpdateProjectProtectionBypassResponseBody,
@@ -362,3 +468,30 @@ export namespace UpdateProjectProtectionBypassResponseBody$ {
   /** @deprecated use `UpdateProjectProtectionBypassResponseBody$Outbound` instead. */
   export type Outbound = UpdateProjectProtectionBypassResponseBody$Outbound;
 }
+
+export function updateProjectProtectionBypassResponseBodyToJSON(
+  updateProjectProtectionBypassResponseBody:
+    UpdateProjectProtectionBypassResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectProtectionBypassResponseBody$outboundSchema.parse(
+      updateProjectProtectionBypassResponseBody,
+    ),
+  );
+}
+
+export function updateProjectProtectionBypassResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectProtectionBypassResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProtectionBypassResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectProtectionBypassResponseBody' from JSON`,
+  );
+}

package/src/models/operations/updaterecord.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 type of the DNS record
@@ -177,6 +180,20 @@ export namespace Srv$ {
   export type Outbound = Srv$Outbound;
 }
 
+export function srvToJSON(srv: Srv): string {
+  return JSON.stringify(Srv$outboundSchema.parse(srv));
+}
+
+export function srvFromJSON(
+  jsonString: string,
+): SafeParseResult<Srv, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Srv$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Srv' from JSON`,
+  );
+}
+
 /** @internal */
 export const Https$inboundSchema: z.ZodType<Https, z.ZodTypeDef, unknown> = z
   .object({
@@ -216,6 +233,20 @@ export namespace Https$ {
   export type Outbound = Https$Outbound;
 }
 
+export function httpsToJSON(https: Https): string {
+  return JSON.stringify(Https$outboundSchema.parse(https));
+}
+
+export function httpsFromJSON(
+  jsonString: string,
+): SafeParseResult<Https, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Https$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Https' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateRecordRequestBody$inboundSchema: z.ZodType<
   UpdateRecordRequestBody,
@@ -273,6 +304,24 @@ export namespace UpdateRecordRequestBody$ {
   export type Outbound = UpdateRecordRequestBody$Outbound;
 }
 
+export function updateRecordRequestBodyToJSON(
+  updateRecordRequestBody: UpdateRecordRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateRecordRequestBody$outboundSchema.parse(updateRecordRequestBody),
+  );
+}
+
+export function updateRecordRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateRecordRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateRecordRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateRecordRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateRecordRequest$inboundSchema: z.ZodType<
   UpdateRecordRequest,
@@ -326,6 +375,24 @@ export namespace UpdateRecordRequest$ {
   export type Outbound = UpdateRecordRequest$Outbound;
 }
 
+export function updateRecordRequestToJSON(
+  updateRecordRequest: UpdateRecordRequest,
+): string {
+  return JSON.stringify(
+    UpdateRecordRequest$outboundSchema.parse(updateRecordRequest),
+  );
+}
+
+export function updateRecordRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateRecordRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateRecordRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateRecordRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const RecordType$inboundSchema: z.ZodNativeEnum<typeof RecordType> = z
   .nativeEnum(RecordType);
@@ -428,3 +495,21 @@ export namespace UpdateRecordResponseBody$ {
   /** @deprecated use `UpdateRecordResponseBody$Outbound` instead. */
   export type Outbound = UpdateRecordResponseBody$Outbound;
 }
+
+export function updateRecordResponseBodyToJSON(
+  updateRecordResponseBody: UpdateRecordResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateRecordResponseBody$outboundSchema.parse(updateRecordResponseBody),
+  );
+}
+
+export function updateRecordResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateRecordResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateRecordResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateRecordResponseBody' from JSON`,
+  );
+}

package/src/models/operations/updateteammember.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 project role of the member that will be added. \"null\" will remove this project level role.
@@ -126,6 +129,24 @@ export namespace UpdateTeamMemberProjects$ {
   export type Outbound = UpdateTeamMemberProjects$Outbound;
 }
 
+export function updateTeamMemberProjectsToJSON(
+  updateTeamMemberProjects: UpdateTeamMemberProjects,
+): string {
+  return JSON.stringify(
+    UpdateTeamMemberProjects$outboundSchema.parse(updateTeamMemberProjects),
+  );
+}
+
+export function updateTeamMemberProjectsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateTeamMemberProjects, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateTeamMemberProjects$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateTeamMemberProjects' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateTeamMemberJoinedFrom$inboundSchema: z.ZodType<
   UpdateTeamMemberJoinedFrom,
@@ -162,6 +183,24 @@ export namespace UpdateTeamMemberJoinedFrom$ {
   export type Outbound = UpdateTeamMemberJoinedFrom$Outbound;
 }
 
+export function updateTeamMemberJoinedFromToJSON(
+  updateTeamMemberJoinedFrom: UpdateTeamMemberJoinedFrom,
+): string {
+  return JSON.stringify(
+    UpdateTeamMemberJoinedFrom$outboundSchema.parse(updateTeamMemberJoinedFrom),
+  );
+}
+
+export function updateTeamMemberJoinedFromFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateTeamMemberJoinedFrom, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateTeamMemberJoinedFrom$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateTeamMemberJoinedFrom' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateTeamMemberRequestBody$inboundSchema: z.ZodType<
   UpdateTeamMemberRequestBody,
@@ -210,6 +249,26 @@ export namespace UpdateTeamMemberRequestBody$ {
   export type Outbound = UpdateTeamMemberRequestBody$Outbound;
 }
 
+export function updateTeamMemberRequestBodyToJSON(
+  updateTeamMemberRequestBody: UpdateTeamMemberRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateTeamMemberRequestBody$outboundSchema.parse(
+      updateTeamMemberRequestBody,
+    ),
+  );
+}
+
+export function updateTeamMemberRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateTeamMemberRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateTeamMemberRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateTeamMemberRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateTeamMemberRequest$inboundSchema: z.ZodType<
   UpdateTeamMemberRequest,
@@ -262,6 +321,24 @@ export namespace UpdateTeamMemberRequest$ {
   export type Outbound = UpdateTeamMemberRequest$Outbound;
 }
 
+export function updateTeamMemberRequestToJSON(
+  updateTeamMemberRequest: UpdateTeamMemberRequest,
+): string {
+  return JSON.stringify(
+    UpdateTeamMemberRequest$outboundSchema.parse(updateTeamMemberRequest),
+  );
+}
+
+export function updateTeamMemberRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateTeamMemberRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateTeamMemberRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateTeamMemberRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateTeamMemberResponseBody$inboundSchema: z.ZodType<
   UpdateTeamMemberResponseBody,
@@ -297,3 +374,23 @@ export namespace UpdateTeamMemberResponseBody$ {
   /** @deprecated use `UpdateTeamMemberResponseBody$Outbound` instead. */
   export type Outbound = UpdateTeamMemberResponseBody$Outbound;
 }
+
+export function updateTeamMemberResponseBodyToJSON(
+  updateTeamMemberResponseBody: UpdateTeamMemberResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateTeamMemberResponseBody$outboundSchema.parse(
+      updateTeamMemberResponseBody,
+    ),
+  );
+}
+
+export function updateTeamMemberResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateTeamMemberResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateTeamMemberResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateTeamMemberResponseBody' from JSON`,
+  );
+}

package/src/models/operations/uploadartifact.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 UploadArtifactRequest = {
   /**
@@ -149,6 +152,24 @@ export namespace UploadArtifactRequest$ {
   export type Outbound = UploadArtifactRequest$Outbound;
 }
 
+export function uploadArtifactRequestToJSON(
+  uploadArtifactRequest: UploadArtifactRequest,
+): string {
+  return JSON.stringify(
+    UploadArtifactRequest$outboundSchema.parse(uploadArtifactRequest),
+  );
+}
+
+export function uploadArtifactRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadArtifactRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadArtifactRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadArtifactRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadArtifactResponseBody$inboundSchema: z.ZodType<
   UploadArtifactResponseBody,
@@ -184,3 +205,21 @@ export namespace UploadArtifactResponseBody$ {
   /** @deprecated use `UploadArtifactResponseBody$Outbound` instead. */
   export type Outbound = UploadArtifactResponseBody$Outbound;
 }
+
+export function uploadArtifactResponseBodyToJSON(
+  uploadArtifactResponseBody: UploadArtifactResponseBody,
+): string {
+  return JSON.stringify(
+    UploadArtifactResponseBody$outboundSchema.parse(uploadArtifactResponseBody),
+  );
+}
+
+export function uploadArtifactResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadArtifactResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadArtifactResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadArtifactResponseBody' from JSON`,
+  );
+}

package/src/models/operations/uploadcert.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 UploadCertRequestBody = {
   /**
@@ -89,6 +92,24 @@ export namespace UploadCertRequestBody$ {
   export type Outbound = UploadCertRequestBody$Outbound;
 }
 
+export function uploadCertRequestBodyToJSON(
+  uploadCertRequestBody: UploadCertRequestBody,
+): string {
+  return JSON.stringify(
+    UploadCertRequestBody$outboundSchema.parse(uploadCertRequestBody),
+  );
+}
+
+export function uploadCertRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadCertRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadCertRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadCertRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadCertRequest$inboundSchema: z.ZodType<
   UploadCertRequest,
@@ -139,6 +160,24 @@ export namespace UploadCertRequest$ {
   export type Outbound = UploadCertRequest$Outbound;
 }
 
+export function uploadCertRequestToJSON(
+  uploadCertRequest: UploadCertRequest,
+): string {
+  return JSON.stringify(
+    UploadCertRequest$outboundSchema.parse(uploadCertRequest),
+  );
+}
+
+export function uploadCertRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadCertRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadCertRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadCertRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadCertResponseBody$inboundSchema: z.ZodType<
   UploadCertResponseBody,
@@ -186,3 +225,21 @@ export namespace UploadCertResponseBody$ {
   /** @deprecated use `UploadCertResponseBody$Outbound` instead. */
   export type Outbound = UploadCertResponseBody$Outbound;
 }
+
+export function uploadCertResponseBodyToJSON(
+  uploadCertResponseBody: UploadCertResponseBody,
+): string {
+  return JSON.stringify(
+    UploadCertResponseBody$outboundSchema.parse(uploadCertResponseBody),
+  );
+}
+
+export function uploadCertResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadCertResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadCertResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadCertResponseBody' from JSON`,
+  );
+}