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

package/src/models/operations/updateproject.ts

@@ -4,12 +4,15 @@
 
 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 {
   ACLAction,
   ACLAction$inboundSchema,
   ACLAction$outboundSchema,
 } from "../components/aclaction.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The framework that is being used for this project. When `null` is used no framework is selected
@@ -434,10 +437,10 @@ export type UpdateProjectTarget = Array<string> | UpdateProjectTarget2;
 
 export const UpdateProjectType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type UpdateProjectType = ClosedEnum<typeof UpdateProjectType>;
 
@@ -1041,29 +1044,15 @@ export type UpdateProjectLink =
   | UpdateProjectLink3
   | UpdateProjectLink2;
 
-/**
- * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
- */
-export type UpdateProjectGroup = {
-  /**
-   * A unique identifier for the group of microfrontends. All related microfrontend projects will share this group ID. Example: mfe_12HKQaOmR5t5Uy6vdcQsNIiZgHGB
-   */
-  id: string;
-  /**
-   * A human readable name for the microfrontends group. This will be used to display the microfrontends group in the UI.
-   */
-  slug: string;
-};
-
 export type UpdateProjectMicrofrontends = {
   /**
    * Timestamp when the microfrontends settings were last updated.
    */
   updatedAt: number;
   /**
-   * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
+   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
    */
-  group: UpdateProjectGroup;
+  groupIds: Array<string>;
   /**
    * Whether microfrontends are enabled for this project.
    */
@@ -1382,6 +1371,7 @@ export type UpdateProjectPermissions = {
   teamInvite?: Array<ACLAction> | undefined;
   teamInviteCode?: Array<ACLAction> | undefined;
   teamJoin?: Array<ACLAction> | undefined;
+  teamMicrofrontends?: Array<ACLAction> | undefined;
   teamOwnMembership?: Array<ACLAction> | undefined;
   teamOwnMembershipDisconnectSAML?: Array<ACLAction> | undefined;
   token?: Array<ACLAction> | undefined;
@@ -1411,6 +1401,7 @@ export type UpdateProjectPermissions = {
   deploymentCheckPreview?: Array<ACLAction> | undefined;
   deploymentCheckReRunFromProductionBranch?: Array<ACLAction> | undefined;
   deploymentProductionGit?: Array<ACLAction> | undefined;
+  deploymentV0?: Array<ACLAction> | undefined;
   deploymentPreview?: Array<ACLAction> | undefined;
   deploymentPrivate?: Array<ACLAction> | undefined;
   deploymentPromote?: Array<ACLAction> | undefined;
@@ -1422,6 +1413,7 @@ export type UpdateProjectPermissions = {
   optionsAllowlist?: Array<ACLAction> | undefined;
   job?: Array<ACLAction> | undefined;
   project?: Array<ACLAction> | undefined;
+  projectFromV0?: Array<ACLAction> | undefined;
   projectAccessGroup?: Array<ACLAction> | undefined;
   projectAnalyticsSampling?: Array<ACLAction> | undefined;
   projectDeploymentHook?: Array<ACLAction> | undefined;
@@ -1460,11 +1452,11 @@ export type UpdateProjectPermissions = {
 export type UpdateProjectLastRollbackTarget = {};
 
 export const UpdateProjectJobStatus = {
-  Pending: "pending",
-  InProgress: "in-progress",
   Succeeded: "succeeded",
   Failed: "failed",
   Skipped: "skipped",
+  Pending: "pending",
+  InProgress: "in-progress",
 } as const;
 export type UpdateProjectJobStatus = ClosedEnum<typeof UpdateProjectJobStatus>;
 
@@ -1717,6 +1709,7 @@ export type UpdateProjectSecurity = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1933,6 +1926,26 @@ export namespace UpdateProjectOidcTokenConfig$ {
   export type Outbound = UpdateProjectOidcTokenConfig$Outbound;
 }
 
+export function updateProjectOidcTokenConfigToJSON(
+  updateProjectOidcTokenConfig: UpdateProjectOidcTokenConfig,
+): string {
+  return JSON.stringify(
+    UpdateProjectOidcTokenConfig$outboundSchema.parse(
+      updateProjectOidcTokenConfig,
+    ),
+  );
+}
+
+export function updateProjectOidcTokenConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectOidcTokenConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectOidcTokenConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectOidcTokenConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof DeploymentType
@@ -1993,6 +2006,24 @@ export namespace PasswordProtection$ {
   export type Outbound = PasswordProtection$Outbound;
 }
 
+export function passwordProtectionToJSON(
+  passwordProtection: PasswordProtection,
+): string {
+  return JSON.stringify(
+    PasswordProtection$outboundSchema.parse(passwordProtection),
+  );
+}
+
+export function passwordProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<PasswordProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PasswordProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PasswordProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDeploymentType
@@ -2050,6 +2081,20 @@ export namespace SsoProtection$ {
   export type Outbound = SsoProtection$Outbound;
 }
 
+export function ssoProtectionToJSON(ssoProtection: SsoProtection): string {
+  return JSON.stringify(SsoProtection$outboundSchema.parse(ssoProtection));
+}
+
+export function ssoProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<SsoProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SsoProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SsoProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsDeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProjectsDeploymentType
@@ -2112,6 +2157,20 @@ export namespace Addresses$ {
   export type Outbound = Addresses$Outbound;
 }
 
+export function addressesToJSON(addresses: Addresses): string {
+  return JSON.stringify(Addresses$outboundSchema.parse(addresses));
+}
+
+export function addressesFromJSON(
+  jsonString: string,
+): SafeParseResult<Addresses, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Addresses$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Addresses' from JSON`,
+  );
+}
+
 /** @internal */
 export const ProtectionMode$inboundSchema: z.ZodNativeEnum<
   typeof ProtectionMode
@@ -2175,6 +2234,20 @@ export namespace TrustedIps$ {
   export type Outbound = TrustedIps$Outbound;
 }
 
+export function trustedIpsToJSON(trustedIps: TrustedIps): string {
+  return JSON.stringify(TrustedIps$outboundSchema.parse(trustedIps));
+}
+
+export function trustedIpsFromJSON(
+  jsonString: string,
+): SafeParseResult<TrustedIps, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrustedIps$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrustedIps' from JSON`,
+  );
+}
+
 /** @internal */
 export const Paths$inboundSchema: z.ZodType<Paths, z.ZodTypeDef, unknown> = z
   .object({
@@ -2208,6 +2281,20 @@ export namespace Paths$ {
   export type Outbound = Paths$Outbound;
 }
 
+export function pathsToJSON(paths: Paths): string {
+  return JSON.stringify(Paths$outboundSchema.parse(paths));
+}
+
+export function pathsFromJSON(
+  jsonString: string,
+): SafeParseResult<Paths, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Paths$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Paths' from JSON`,
+  );
+}
+
 /** @internal */
 export const OptionsAllowlist$inboundSchema: z.ZodType<
   OptionsAllowlist,
@@ -2244,6 +2331,24 @@ export namespace OptionsAllowlist$ {
   export type Outbound = OptionsAllowlist$Outbound;
 }
 
+export function optionsAllowlistToJSON(
+  optionsAllowlist: OptionsAllowlist,
+): string {
+  return JSON.stringify(
+    OptionsAllowlist$outboundSchema.parse(optionsAllowlist),
+  );
+}
+
+export function optionsAllowlistFromJSON(
+  jsonString: string,
+): SafeParseResult<OptionsAllowlist, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OptionsAllowlist$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OptionsAllowlist' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectRequestBody$inboundSchema: z.ZodType<
   UpdateProjectRequestBody,
@@ -2382,6 +2487,24 @@ export namespace UpdateProjectRequestBody$ {
   export type Outbound = UpdateProjectRequestBody$Outbound;
 }
 
+export function updateProjectRequestBodyToJSON(
+  updateProjectRequestBody: UpdateProjectRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectRequestBody$outboundSchema.parse(updateProjectRequestBody),
+  );
+}
+
+export function updateProjectRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectRequest$inboundSchema: z.ZodType<
   UpdateProjectRequest,
@@ -2435,6 +2558,24 @@ export namespace UpdateProjectRequest$ {
   export type Outbound = UpdateProjectRequest$Outbound;
 }
 
+export function updateProjectRequestToJSON(
+  updateProjectRequest: UpdateProjectRequest,
+): string {
+  return JSON.stringify(
+    UpdateProjectRequest$outboundSchema.parse(updateProjectRequest),
+  );
+}
+
+export function updateProjectRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectAnalytics$inboundSchema: z.ZodType<
   UpdateProjectAnalytics,
@@ -2489,6 +2630,24 @@ export namespace UpdateProjectAnalytics$ {
   export type Outbound = UpdateProjectAnalytics$Outbound;
 }
 
+export function updateProjectAnalyticsToJSON(
+  updateProjectAnalytics: UpdateProjectAnalytics,
+): string {
+  return JSON.stringify(
+    UpdateProjectAnalytics$outboundSchema.parse(updateProjectAnalytics),
+  );
+}
+
+export function updateProjectAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectSpeedInsights$inboundSchema: z.ZodType<
   UpdateProjectSpeedInsights,
@@ -2540,6 +2699,24 @@ export namespace UpdateProjectSpeedInsights$ {
   export type Outbound = UpdateProjectSpeedInsights$Outbound;
 }
 
+export function updateProjectSpeedInsightsToJSON(
+  updateProjectSpeedInsights: UpdateProjectSpeedInsights,
+): string {
+  return JSON.stringify(
+    UpdateProjectSpeedInsights$outboundSchema.parse(updateProjectSpeedInsights),
+  );
+}
+
+export function updateProjectSpeedInsightsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectSpeedInsights, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectSpeedInsights$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectSpeedInsights' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDefinitions$inboundSchema: z.ZodType<
   UpdateProjectDefinitions,
@@ -2582,6 +2759,24 @@ export namespace UpdateProjectDefinitions$ {
   export type Outbound = UpdateProjectDefinitions$Outbound;
 }
 
+export function updateProjectDefinitionsToJSON(
+  updateProjectDefinitions: UpdateProjectDefinitions,
+): string {
+  return JSON.stringify(
+    UpdateProjectDefinitions$outboundSchema.parse(updateProjectDefinitions),
+  );
+}
+
+export function updateProjectDefinitionsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDefinitions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDefinitions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDefinitions' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectCrons$inboundSchema: z.ZodType<
   UpdateProjectCrons,
@@ -2630,6 +2825,24 @@ export namespace UpdateProjectCrons$ {
   export type Outbound = UpdateProjectCrons$Outbound;
 }
 
+export function updateProjectCronsToJSON(
+  updateProjectCrons: UpdateProjectCrons,
+): string {
+  return JSON.stringify(
+    UpdateProjectCrons$outboundSchema.parse(updateProjectCrons),
+  );
+}
+
+export function updateProjectCronsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectCrons, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectCrons$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectCrons' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCache$inboundSchema: z.ZodType<
   UpdateProjectDataCache,
@@ -2672,6 +2885,24 @@ export namespace UpdateProjectDataCache$ {
   export type Outbound = UpdateProjectDataCache$Outbound;
 }
 
+export function updateProjectDataCacheToJSON(
+  updateProjectDataCache: UpdateProjectDataCache,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCache$outboundSchema.parse(updateProjectDataCache),
+  );
+}
+
+export function updateProjectDataCacheFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCache, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCache$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCache' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDeploymentExpiration$inboundSchema: z.ZodType<
   UpdateProjectDeploymentExpiration,
@@ -2721,6 +2952,26 @@ export namespace UpdateProjectDeploymentExpiration$ {
   export type Outbound = UpdateProjectDeploymentExpiration$Outbound;
 }
 
+export function updateProjectDeploymentExpirationToJSON(
+  updateProjectDeploymentExpiration: UpdateProjectDeploymentExpiration,
+): string {
+  return JSON.stringify(
+    UpdateProjectDeploymentExpiration$outboundSchema.parse(
+      updateProjectDeploymentExpiration,
+    ),
+  );
+}
+
+export function updateProjectDeploymentExpirationFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDeploymentExpiration, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDeploymentExpiration$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDeploymentExpiration' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTarget2$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectTarget2
@@ -2772,6 +3023,24 @@ export namespace UpdateProjectTarget$ {
   export type Outbound = UpdateProjectTarget$Outbound;
 }
 
+export function updateProjectTargetToJSON(
+  updateProjectTarget: UpdateProjectTarget,
+): string {
+  return JSON.stringify(
+    UpdateProjectTarget$outboundSchema.parse(updateProjectTarget),
+  );
+}
+
+export function updateProjectTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectType
@@ -2862,6 +3131,24 @@ export namespace UpdateProjectContentHint15$ {
   export type Outbound = UpdateProjectContentHint15$Outbound;
 }
 
+export function updateProjectContentHint15ToJSON(
+  updateProjectContentHint15: UpdateProjectContentHint15,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint15$outboundSchema.parse(updateProjectContentHint15),
+  );
+}
+
+export function updateProjectContentHint15FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint15' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2940,6 +3227,24 @@ export namespace UpdateProjectContentHint14$ {
   export type Outbound = UpdateProjectContentHint14$Outbound;
 }
 
+export function updateProjectContentHint14ToJSON(
+  updateProjectContentHint14: UpdateProjectContentHint14,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint14$outboundSchema.parse(updateProjectContentHint14),
+  );
+}
+
+export function updateProjectContentHint14FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint14' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3009,6 +3314,24 @@ export namespace UpdateProjectContentHint13$ {
   export type Outbound = UpdateProjectContentHint13$Outbound;
 }
 
+export function updateProjectContentHint13ToJSON(
+  updateProjectContentHint13: UpdateProjectContentHint13,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint13$outboundSchema.parse(updateProjectContentHint13),
+  );
+}
+
+export function updateProjectContentHint13FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint13' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3078,6 +3401,24 @@ export namespace UpdateProjectContentHint12$ {
   export type Outbound = UpdateProjectContentHint12$Outbound;
 }
 
+export function updateProjectContentHint12ToJSON(
+  updateProjectContentHint12: UpdateProjectContentHint12,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint12$outboundSchema.parse(updateProjectContentHint12),
+  );
+}
+
+export function updateProjectContentHint12FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint12' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3147,6 +3488,24 @@ export namespace UpdateProjectContentHint11$ {
   export type Outbound = UpdateProjectContentHint11$Outbound;
 }
 
+export function updateProjectContentHint11ToJSON(
+  updateProjectContentHint11: UpdateProjectContentHint11,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint11$outboundSchema.parse(updateProjectContentHint11),
+  );
+}
+
+export function updateProjectContentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3216,6 +3575,24 @@ export namespace UpdateProjectContentHint10$ {
   export type Outbound = UpdateProjectContentHint10$Outbound;
 }
 
+export function updateProjectContentHint10ToJSON(
+  updateProjectContentHint10: UpdateProjectContentHint10,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint10$outboundSchema.parse(updateProjectContentHint10),
+  );
+}
+
+export function updateProjectContentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3285,6 +3662,24 @@ export namespace UpdateProjectContentHint9$ {
   export type Outbound = UpdateProjectContentHint9$Outbound;
 }
 
+export function updateProjectContentHint9ToJSON(
+  updateProjectContentHint9: UpdateProjectContentHint9,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint9$outboundSchema.parse(updateProjectContentHint9),
+  );
+}
+
+export function updateProjectContentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv8Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3354,6 +3749,24 @@ export namespace UpdateProjectContentHint8$ {
   export type Outbound = UpdateProjectContentHint8$Outbound;
 }
 
+export function updateProjectContentHint8ToJSON(
+  updateProjectContentHint8: UpdateProjectContentHint8,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint8$outboundSchema.parse(updateProjectContentHint8),
+  );
+}
+
+export function updateProjectContentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
   z.ZodNativeEnum<
@@ -3423,6 +3836,24 @@ export namespace UpdateProjectContentHint7$ {
   export type Outbound = UpdateProjectContentHint7$Outbound;
 }
 
+export function updateProjectContentHint7ToJSON(
+  updateProjectContentHint7: UpdateProjectContentHint7,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint7$outboundSchema.parse(updateProjectContentHint7),
+  );
+}
+
+export function updateProjectContentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -3492,6 +3923,24 @@ export namespace UpdateProjectContentHint6$ {
   export type Outbound = UpdateProjectContentHint6$Outbound;
 }
 
+export function updateProjectContentHint6ToJSON(
+  updateProjectContentHint6: UpdateProjectContentHint6,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint6$outboundSchema.parse(updateProjectContentHint6),
+  );
+}
+
+export function updateProjectContentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -3561,6 +4010,24 @@ export namespace UpdateProjectContentHint5$ {
   export type Outbound = UpdateProjectContentHint5$Outbound;
 }
 
+export function updateProjectContentHint5ToJSON(
+  updateProjectContentHint5: UpdateProjectContentHint5,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint5$outboundSchema.parse(updateProjectContentHint5),
+  );
+}
+
+export function updateProjectContentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectContentHintProjectsResponse200Type> = z
@@ -3623,6 +4090,24 @@ export namespace UpdateProjectContentHint4$ {
   export type Outbound = UpdateProjectContentHint4$Outbound;
 }
 
+export function updateProjectContentHint4ToJSON(
+  updateProjectContentHint4: UpdateProjectContentHint4,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint4$outboundSchema.parse(updateProjectContentHint4),
+  );
+}
+
+export function updateProjectContentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectContentHintProjectsResponseType> = z
@@ -3685,6 +4170,24 @@ export namespace UpdateProjectContentHint3$ {
   export type Outbound = UpdateProjectContentHint3$Outbound;
 }
 
+export function updateProjectContentHint3ToJSON(
+  updateProjectContentHint3: UpdateProjectContentHint3,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint3$outboundSchema.parse(updateProjectContentHint3),
+  );
+}
+
+export function updateProjectContentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectContentHintProjectsType> = z.nativeEnum(
@@ -3748,6 +4251,24 @@ export namespace UpdateProjectContentHint2$ {
   export type Outbound = UpdateProjectContentHint2$Outbound;
 }
 
+export function updateProjectContentHint2ToJSON(
+  updateProjectContentHint2: UpdateProjectContentHint2,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint2$outboundSchema.parse(updateProjectContentHint2),
+  );
+}
+
+export function updateProjectContentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectContentHintType
@@ -3808,6 +4329,24 @@ export namespace UpdateProjectContentHint1$ {
   export type Outbound = UpdateProjectContentHint1$Outbound;
 }
 
+export function updateProjectContentHint1ToJSON(
+  updateProjectContentHint1: UpdateProjectContentHint1,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint1$outboundSchema.parse(updateProjectContentHint1),
+  );
+}
+
+export function updateProjectContentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectContentHint$inboundSchema: z.ZodType<
   UpdateProjectContentHint,
@@ -3885,6 +4424,24 @@ export namespace UpdateProjectContentHint$ {
   export type Outbound = UpdateProjectContentHint$Outbound;
 }
 
+export function updateProjectContentHintToJSON(
+  updateProjectContentHint: UpdateProjectContentHint,
+): string {
+  return JSON.stringify(
+    UpdateProjectContentHint$outboundSchema.parse(updateProjectContentHint),
+  );
+}
+
+export function updateProjectContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
   z.ZodNativeEnum<
@@ -3954,6 +4511,26 @@ export namespace UpdateProjectInternalContentHint$ {
   export type Outbound = UpdateProjectInternalContentHint$Outbound;
 }
 
+export function updateProjectInternalContentHintToJSON(
+  updateProjectInternalContentHint: UpdateProjectInternalContentHint,
+): string {
+  return JSON.stringify(
+    UpdateProjectInternalContentHint$outboundSchema.parse(
+      updateProjectInternalContentHint,
+    ),
+  );
+}
+
+export function updateProjectInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectInternalContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectInternalContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectEnv$inboundSchema: z.ZodType<
   UpdateProjectEnv,
@@ -4109,6 +4686,24 @@ export namespace UpdateProjectEnv$ {
   export type Outbound = UpdateProjectEnv$Outbound;
 }
 
+export function updateProjectEnvToJSON(
+  updateProjectEnv: UpdateProjectEnv,
+): string {
+  return JSON.stringify(
+    UpdateProjectEnv$outboundSchema.parse(updateProjectEnv),
+  );
+}
+
+export function updateProjectEnvFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectEnv, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectEnv$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectEnv' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectCustomEnvironments$inboundSchema: z.ZodType<
   UpdateProjectCustomEnvironments,
@@ -4139,6 +4734,26 @@ export namespace UpdateProjectCustomEnvironments$ {
   export type Outbound = UpdateProjectCustomEnvironments$Outbound;
 }
 
+export function updateProjectCustomEnvironmentsToJSON(
+  updateProjectCustomEnvironments: UpdateProjectCustomEnvironments,
+): string {
+  return JSON.stringify(
+    UpdateProjectCustomEnvironments$outboundSchema.parse(
+      updateProjectCustomEnvironments,
+    ),
+  );
+}
+
+export function updateProjectCustomEnvironmentsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectCustomEnvironments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectCustomEnvironments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectCustomEnvironments' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsFramework$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProjectsFramework
@@ -4199,6 +4814,24 @@ export namespace UpdateProjectIpBuckets$ {
   export type Outbound = UpdateProjectIpBuckets$Outbound;
 }
 
+export function updateProjectIpBucketsToJSON(
+  updateProjectIpBuckets: UpdateProjectIpBuckets,
+): string {
+  return JSON.stringify(
+    UpdateProjectIpBuckets$outboundSchema.parse(updateProjectIpBuckets),
+  );
+}
+
+export function updateProjectIpBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectIpBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectIpBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectIpBuckets' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectAliasAssigned$inboundSchema: z.ZodType<
   UpdateProjectAliasAssigned,
@@ -4229,6 +4862,24 @@ export namespace UpdateProjectAliasAssigned$ {
   export type Outbound = UpdateProjectAliasAssigned$Outbound;
 }
 
+export function updateProjectAliasAssignedToJSON(
+  updateProjectAliasAssigned: UpdateProjectAliasAssigned,
+): string {
+  return JSON.stringify(
+    UpdateProjectAliasAssigned$outboundSchema.parse(updateProjectAliasAssigned),
+  );
+}
+
+export function updateProjectAliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectAliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectAliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectAliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectAliasError$inboundSchema: z.ZodType<
   UpdateProjectAliasError,
@@ -4268,6 +4919,24 @@ export namespace UpdateProjectAliasError$ {
   export type Outbound = UpdateProjectAliasError$Outbound;
 }
 
+export function updateProjectAliasErrorToJSON(
+  updateProjectAliasError: UpdateProjectAliasError,
+): string {
+  return JSON.stringify(
+    UpdateProjectAliasError$outboundSchema.parse(updateProjectAliasError),
+  );
+}
+
+export function updateProjectAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectAliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectAliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -4337,6 +5006,24 @@ export namespace UpdateProjectBranchMatcher$ {
   export type Outbound = UpdateProjectBranchMatcher$Outbound;
 }
 
+export function updateProjectBranchMatcherToJSON(
+  updateProjectBranchMatcher: UpdateProjectBranchMatcher,
+): string {
+  return JSON.stringify(
+    UpdateProjectBranchMatcher$outboundSchema.parse(updateProjectBranchMatcher),
+  );
+}
+
+export function updateProjectBranchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectBranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectBranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectBranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectBuilds$inboundSchema: z.ZodType<
   UpdateProjectBuilds,
@@ -4379,6 +5066,24 @@ export namespace UpdateProjectBuilds$ {
   export type Outbound = UpdateProjectBuilds$Outbound;
 }
 
+export function updateProjectBuildsToJSON(
+  updateProjectBuilds: UpdateProjectBuilds,
+): string {
+  return JSON.stringify(
+    UpdateProjectBuilds$outboundSchema.parse(updateProjectBuilds),
+  );
+}
+
+export function updateProjectBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectChecksConclusion$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectChecksConclusion
@@ -4469,11 +5174,29 @@ export namespace UpdateProjectCreator$ {
   export type Outbound = UpdateProjectCreator$Outbound;
 }
 
-/** @internal */
-export const UpdateProjectOidcTokenClaims$inboundSchema: z.ZodType<
-  UpdateProjectOidcTokenClaims,
-  z.ZodTypeDef,
-  unknown
+export function updateProjectCreatorToJSON(
+  updateProjectCreator: UpdateProjectCreator,
+): string {
+  return JSON.stringify(
+    UpdateProjectCreator$outboundSchema.parse(updateProjectCreator),
+  );
+}
+
+export function updateProjectCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectCreator' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateProjectOidcTokenClaims$inboundSchema: z.ZodType<
+  UpdateProjectOidcTokenClaims,
+  z.ZodTypeDef,
+  unknown
 > = z.object({
   iss: z.string(),
   sub: z.string(),
@@ -4539,6 +5262,26 @@ export namespace UpdateProjectOidcTokenClaims$ {
   export type Outbound = UpdateProjectOidcTokenClaims$Outbound;
 }
 
+export function updateProjectOidcTokenClaimsToJSON(
+  updateProjectOidcTokenClaims: UpdateProjectOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    UpdateProjectOidcTokenClaims$outboundSchema.parse(
+      updateProjectOidcTokenClaims,
+    ),
+  );
+}
+
+export function updateProjectOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectOidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectOidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectPlan$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectPlan
@@ -4770,6 +5513,26 @@ export namespace UpdateProjectLatestDeployments$ {
   export type Outbound = UpdateProjectLatestDeployments$Outbound;
 }
 
+export function updateProjectLatestDeploymentsToJSON(
+  updateProjectLatestDeployments: UpdateProjectLatestDeployments,
+): string {
+  return JSON.stringify(
+    UpdateProjectLatestDeployments$outboundSchema.parse(
+      updateProjectLatestDeployments,
+    ),
+  );
+}
+
+export function updateProjectLatestDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLatestDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLatestDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLatestDeployments' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLinkProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectLinkProjectsResponseType> = z.nativeEnum(
@@ -4846,6 +5609,33 @@ export namespace UpdateProjectLinkProjectsResponseDeployHooks$ {
   export type Outbound = UpdateProjectLinkProjectsResponseDeployHooks$Outbound;
 }
 
+export function updateProjectLinkProjectsResponseDeployHooksToJSON(
+  updateProjectLinkProjectsResponseDeployHooks:
+    UpdateProjectLinkProjectsResponseDeployHooks,
+): string {
+  return JSON.stringify(
+    UpdateProjectLinkProjectsResponseDeployHooks$outboundSchema.parse(
+      updateProjectLinkProjectsResponseDeployHooks,
+    ),
+  );
+}
+
+export function updateProjectLinkProjectsResponseDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectLinkProjectsResponseDeployHooks,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectLinkProjectsResponseDeployHooks$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectLinkProjectsResponseDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLink3$inboundSchema: z.ZodType<
   UpdateProjectLink3,
@@ -4919,6 +5709,24 @@ export namespace UpdateProjectLink3$ {
   export type Outbound = UpdateProjectLink3$Outbound;
 }
 
+export function updateProjectLink3ToJSON(
+  updateProjectLink3: UpdateProjectLink3,
+): string {
+  return JSON.stringify(
+    UpdateProjectLink3$outboundSchema.parse(updateProjectLink3),
+  );
+}
+
+export function updateProjectLink3FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLink3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLink3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLink3' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLinkProjectsType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectLinkProjectsType
@@ -4990,6 +5798,27 @@ export namespace UpdateProjectLinkProjectsDeployHooks$ {
   export type Outbound = UpdateProjectLinkProjectsDeployHooks$Outbound;
 }
 
+export function updateProjectLinkProjectsDeployHooksToJSON(
+  updateProjectLinkProjectsDeployHooks: UpdateProjectLinkProjectsDeployHooks,
+): string {
+  return JSON.stringify(
+    UpdateProjectLinkProjectsDeployHooks$outboundSchema.parse(
+      updateProjectLinkProjectsDeployHooks,
+    ),
+  );
+}
+
+export function updateProjectLinkProjectsDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLinkProjectsDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectLinkProjectsDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLinkProjectsDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLink2$inboundSchema: z.ZodType<
   UpdateProjectLink2,
@@ -5066,6 +5895,24 @@ export namespace UpdateProjectLink2$ {
   export type Outbound = UpdateProjectLink2$Outbound;
 }
 
+export function updateProjectLink2ToJSON(
+  updateProjectLink2: UpdateProjectLink2,
+): string {
+  return JSON.stringify(
+    UpdateProjectLink2$outboundSchema.parse(updateProjectLink2),
+  );
+}
+
+export function updateProjectLink2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLink2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLink2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLink2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLinkType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectLinkType
@@ -5135,6 +5982,26 @@ export namespace UpdateProjectLinkDeployHooks$ {
   export type Outbound = UpdateProjectLinkDeployHooks$Outbound;
 }
 
+export function updateProjectLinkDeployHooksToJSON(
+  updateProjectLinkDeployHooks: UpdateProjectLinkDeployHooks,
+): string {
+  return JSON.stringify(
+    UpdateProjectLinkDeployHooks$outboundSchema.parse(
+      updateProjectLinkDeployHooks,
+    ),
+  );
+}
+
+export function updateProjectLinkDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLinkDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLinkDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLinkDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLink1$inboundSchema: z.ZodType<
   UpdateProjectLink1,
@@ -5205,6 +6072,24 @@ export namespace UpdateProjectLink1$ {
   export type Outbound = UpdateProjectLink1$Outbound;
 }
 
+export function updateProjectLink1ToJSON(
+  updateProjectLink1: UpdateProjectLink1,
+): string {
+  return JSON.stringify(
+    UpdateProjectLink1$outboundSchema.parse(updateProjectLink1),
+  );
+}
+
+export function updateProjectLink1FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLink1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLink1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLink1' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLink$inboundSchema: z.ZodType<
   UpdateProjectLink,
@@ -5246,43 +6131,22 @@ export namespace UpdateProjectLink$ {
   export type Outbound = UpdateProjectLink$Outbound;
 }
 
-/** @internal */
-export const UpdateProjectGroup$inboundSchema: z.ZodType<
-  UpdateProjectGroup,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  slug: z.string(),
-});
-
-/** @internal */
-export type UpdateProjectGroup$Outbound = {
-  id: string;
-  slug: string;
-};
-
-/** @internal */
-export const UpdateProjectGroup$outboundSchema: z.ZodType<
-  UpdateProjectGroup$Outbound,
-  z.ZodTypeDef,
-  UpdateProjectGroup
-> = z.object({
-  id: z.string(),
-  slug: z.string(),
-});
+export function updateProjectLinkToJSON(
+  updateProjectLink: UpdateProjectLink,
+): string {
+  return JSON.stringify(
+    UpdateProjectLink$outboundSchema.parse(updateProjectLink),
+  );
+}
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace UpdateProjectGroup$ {
-  /** @deprecated use `UpdateProjectGroup$inboundSchema` instead. */
-  export const inboundSchema = UpdateProjectGroup$inboundSchema;
-  /** @deprecated use `UpdateProjectGroup$outboundSchema` instead. */
-  export const outboundSchema = UpdateProjectGroup$outboundSchema;
-  /** @deprecated use `UpdateProjectGroup$Outbound` instead. */
-  export type Outbound = UpdateProjectGroup$Outbound;
+export function updateProjectLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLink' from JSON`,
+  );
 }
 
 /** @internal */
@@ -5292,7 +6156,7 @@ export const UpdateProjectMicrofrontends$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => UpdateProjectGroup$inboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -5301,7 +6165,7 @@ export const UpdateProjectMicrofrontends$inboundSchema: z.ZodType<
 /** @internal */
 export type UpdateProjectMicrofrontends$Outbound = {
   updatedAt: number;
-  group: UpdateProjectGroup$Outbound;
+  groupIds: Array<string>;
   enabled: boolean;
   isDefaultApp?: boolean | undefined;
   defaultRoute?: string | undefined;
@@ -5314,7 +6178,7 @@ export const UpdateProjectMicrofrontends$outboundSchema: z.ZodType<
   UpdateProjectMicrofrontends
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => UpdateProjectGroup$outboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -5333,6 +6197,26 @@ export namespace UpdateProjectMicrofrontends$ {
   export type Outbound = UpdateProjectMicrofrontends$Outbound;
 }
 
+export function updateProjectMicrofrontendsToJSON(
+  updateProjectMicrofrontends: UpdateProjectMicrofrontends,
+): string {
+  return JSON.stringify(
+    UpdateProjectMicrofrontends$outboundSchema.parse(
+      updateProjectMicrofrontends,
+    ),
+  );
+}
+
+export function updateProjectMicrofrontendsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectMicrofrontends, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectMicrofrontends$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectMicrofrontends' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsNodeVersion$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProjectsNodeVersion
@@ -5390,6 +6274,24 @@ export namespace UpdateProjectPaths$ {
   export type Outbound = UpdateProjectPaths$Outbound;
 }
 
+export function updateProjectPathsToJSON(
+  updateProjectPaths: UpdateProjectPaths,
+): string {
+  return JSON.stringify(
+    UpdateProjectPaths$outboundSchema.parse(updateProjectPaths),
+  );
+}
+
+export function updateProjectPathsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectPaths, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectPaths$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectPaths' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectOptionsAllowlist$inboundSchema: z.ZodType<
   UpdateProjectOptionsAllowlist,
@@ -5426,6 +6328,26 @@ export namespace UpdateProjectOptionsAllowlist$ {
   export type Outbound = UpdateProjectOptionsAllowlist$Outbound;
 }
 
+export function updateProjectOptionsAllowlistToJSON(
+  updateProjectOptionsAllowlist: UpdateProjectOptionsAllowlist,
+): string {
+  return JSON.stringify(
+    UpdateProjectOptionsAllowlist$outboundSchema.parse(
+      updateProjectOptionsAllowlist,
+    ),
+  );
+}
+
+export function updateProjectOptionsAllowlistFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectOptionsAllowlist, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectOptionsAllowlist$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectOptionsAllowlist' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectPasswordProtection$inboundSchema: z.ZodType<
   UpdateProjectPasswordProtection,
@@ -5456,6 +6378,26 @@ export namespace UpdateProjectPasswordProtection$ {
   export type Outbound = UpdateProjectPasswordProtection$Outbound;
 }
 
+export function updateProjectPasswordProtectionToJSON(
+  updateProjectPasswordProtection: UpdateProjectPasswordProtection,
+): string {
+  return JSON.stringify(
+    UpdateProjectPasswordProtection$outboundSchema.parse(
+      updateProjectPasswordProtection,
+    ),
+  );
+}
+
+export function updateProjectPasswordProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectPasswordProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectPasswordProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectPasswordProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectFunctionDefaultMemoryType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectFunctionDefaultMemoryType> = z.nativeEnum(
@@ -5527,6 +6469,26 @@ export namespace UpdateProjectResourceConfig$ {
   export type Outbound = UpdateProjectResourceConfig$Outbound;
 }
 
+export function updateProjectResourceConfigToJSON(
+  updateProjectResourceConfig: UpdateProjectResourceConfig,
+): string {
+  return JSON.stringify(
+    UpdateProjectResourceConfig$outboundSchema.parse(
+      updateProjectResourceConfig,
+    ),
+  );
+}
+
+export function updateProjectResourceConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectResourceConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectResourceConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectResourceConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponseDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectProjectsResponseDeploymentType> = z
@@ -5586,6 +6548,24 @@ export namespace UpdateProjectSsoProtection$ {
   export type Outbound = UpdateProjectSsoProtection$Outbound;
 }
 
+export function updateProjectSsoProtectionToJSON(
+  updateProjectSsoProtection: UpdateProjectSsoProtection,
+): string {
+  return JSON.stringify(
+    UpdateProjectSsoProtection$outboundSchema.parse(updateProjectSsoProtection),
+  );
+}
+
+export function updateProjectSsoProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectSsoProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectSsoProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectSsoProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsAliasAssigned$inboundSchema: z.ZodType<
   UpdateProjectProjectsAliasAssigned,
@@ -5617,6 +6597,27 @@ export namespace UpdateProjectProjectsAliasAssigned$ {
   export type Outbound = UpdateProjectProjectsAliasAssigned$Outbound;
 }
 
+export function updateProjectProjectsAliasAssignedToJSON(
+  updateProjectProjectsAliasAssigned: UpdateProjectProjectsAliasAssigned,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsAliasAssigned$outboundSchema.parse(
+      updateProjectProjectsAliasAssigned,
+    ),
+  );
+}
+
+export function updateProjectProjectsAliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsAliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProjectsAliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsAliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsAliasError$inboundSchema: z.ZodType<
   UpdateProjectProjectsAliasError,
@@ -5656,6 +6657,26 @@ export namespace UpdateProjectProjectsAliasError$ {
   export type Outbound = UpdateProjectProjectsAliasError$Outbound;
 }
 
+export function updateProjectProjectsAliasErrorToJSON(
+  updateProjectProjectsAliasError: UpdateProjectProjectsAliasError,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsAliasError$outboundSchema.parse(
+      updateProjectProjectsAliasError,
+    ),
+  );
+}
+
+export function updateProjectProjectsAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsAliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectProjectsAliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONType> =
@@ -5719,6 +6740,27 @@ export namespace UpdateProjectProjectsBranchMatcher$ {
   export type Outbound = UpdateProjectProjectsBranchMatcher$Outbound;
 }
 
+export function updateProjectProjectsBranchMatcherToJSON(
+  updateProjectProjectsBranchMatcher: UpdateProjectProjectsBranchMatcher,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsBranchMatcher$outboundSchema.parse(
+      updateProjectProjectsBranchMatcher,
+    ),
+  );
+}
+
+export function updateProjectProjectsBranchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsBranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProjectsBranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsBranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsBuilds$inboundSchema: z.ZodType<
   UpdateProjectProjectsBuilds,
@@ -5761,6 +6803,26 @@ export namespace UpdateProjectProjectsBuilds$ {
   export type Outbound = UpdateProjectProjectsBuilds$Outbound;
 }
 
+export function updateProjectProjectsBuildsToJSON(
+  updateProjectProjectsBuilds: UpdateProjectProjectsBuilds,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsBuilds$outboundSchema.parse(
+      updateProjectProjectsBuilds,
+    ),
+  );
+}
+
+export function updateProjectProjectsBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectProjectsBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsChecksConclusion$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectProjectsChecksConclusion> = z.nativeEnum(
@@ -5854,6 +6916,26 @@ export namespace UpdateProjectProjectsCreator$ {
   export type Outbound = UpdateProjectProjectsCreator$Outbound;
 }
 
+export function updateProjectProjectsCreatorToJSON(
+  updateProjectProjectsCreator: UpdateProjectProjectsCreator,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsCreator$outboundSchema.parse(
+      updateProjectProjectsCreator,
+    ),
+  );
+}
+
+export function updateProjectProjectsCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectProjectsCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsOidcTokenClaims$inboundSchema: z.ZodType<
   UpdateProjectProjectsOidcTokenClaims,
@@ -5926,6 +7008,27 @@ export namespace UpdateProjectProjectsOidcTokenClaims$ {
   export type Outbound = UpdateProjectProjectsOidcTokenClaims$Outbound;
 }
 
+export function updateProjectProjectsOidcTokenClaimsToJSON(
+  updateProjectProjectsOidcTokenClaims: UpdateProjectProjectsOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsOidcTokenClaims$outboundSchema.parse(
+      updateProjectProjectsOidcTokenClaims,
+    ),
+  );
+}
+
+export function updateProjectProjectsOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsOidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProjectsOidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsPlan$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProjectsPlan
@@ -6169,6 +7272,24 @@ export namespace UpdateProjectTargets$ {
   export type Outbound = UpdateProjectTargets$Outbound;
 }
 
+export function updateProjectTargetsToJSON(
+  updateProjectTargets: UpdateProjectTargets,
+): string {
+  return JSON.stringify(
+    UpdateProjectTargets$outboundSchema.parse(updateProjectTargets),
+  );
+}
+
+export function updateProjectTargetsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTargets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTargets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTargets' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectPermissions$inboundSchema: z.ZodType<
   UpdateProjectPermissions,
@@ -6281,6 +7402,7 @@ export const UpdateProjectPermissions$inboundSchema: z.ZodType<
   teamInvite: z.array(ACLAction$inboundSchema).optional(),
   teamInviteCode: z.array(ACLAction$inboundSchema).optional(),
   teamJoin: z.array(ACLAction$inboundSchema).optional(),
+  teamMicrofrontends: z.array(ACLAction$inboundSchema).optional(),
   teamOwnMembership: z.array(ACLAction$inboundSchema).optional(),
   teamOwnMembershipDisconnectSAML: z.array(ACLAction$inboundSchema).optional(),
   token: z.array(ACLAction$inboundSchema).optional(),
@@ -6311,6 +7433,7 @@ export const UpdateProjectPermissions$inboundSchema: z.ZodType<
   deploymentCheckReRunFromProductionBranch: z.array(ACLAction$inboundSchema)
     .optional(),
   deploymentProductionGit: z.array(ACLAction$inboundSchema).optional(),
+  deploymentV0: z.array(ACLAction$inboundSchema).optional(),
   deploymentPreview: z.array(ACLAction$inboundSchema).optional(),
   deploymentPrivate: z.array(ACLAction$inboundSchema).optional(),
   deploymentPromote: z.array(ACLAction$inboundSchema).optional(),
@@ -6322,6 +7445,7 @@ export const UpdateProjectPermissions$inboundSchema: z.ZodType<
   optionsAllowlist: z.array(ACLAction$inboundSchema).optional(),
   job: z.array(ACLAction$inboundSchema).optional(),
   project: z.array(ACLAction$inboundSchema).optional(),
+  projectFromV0: z.array(ACLAction$inboundSchema).optional(),
   projectAccessGroup: z.array(ACLAction$inboundSchema).optional(),
   projectAnalyticsSampling: z.array(ACLAction$inboundSchema).optional(),
   projectDeploymentHook: z.array(ACLAction$inboundSchema).optional(),
@@ -6470,6 +7594,7 @@ export type UpdateProjectPermissions$Outbound = {
   teamInvite?: Array<string> | undefined;
   teamInviteCode?: Array<string> | undefined;
   teamJoin?: Array<string> | undefined;
+  teamMicrofrontends?: Array<string> | undefined;
   teamOwnMembership?: Array<string> | undefined;
   teamOwnMembershipDisconnectSAML?: Array<string> | undefined;
   token?: Array<string> | undefined;
@@ -6499,6 +7624,7 @@ export type UpdateProjectPermissions$Outbound = {
   deploymentCheckPreview?: Array<string> | undefined;
   deploymentCheckReRunFromProductionBranch?: Array<string> | undefined;
   deploymentProductionGit?: Array<string> | undefined;
+  deploymentV0?: Array<string> | undefined;
   deploymentPreview?: Array<string> | undefined;
   deploymentPrivate?: Array<string> | undefined;
   deploymentPromote?: Array<string> | undefined;
@@ -6510,6 +7636,7 @@ export type UpdateProjectPermissions$Outbound = {
   optionsAllowlist?: Array<string> | undefined;
   job?: Array<string> | undefined;
   project?: Array<string> | undefined;
+  projectFromV0?: Array<string> | undefined;
   projectAccessGroup?: Array<string> | undefined;
   projectAnalyticsSampling?: Array<string> | undefined;
   projectDeploymentHook?: Array<string> | undefined;
@@ -6659,6 +7786,7 @@ export const UpdateProjectPermissions$outboundSchema: z.ZodType<
   teamInvite: z.array(ACLAction$outboundSchema).optional(),
   teamInviteCode: z.array(ACLAction$outboundSchema).optional(),
   teamJoin: z.array(ACLAction$outboundSchema).optional(),
+  teamMicrofrontends: z.array(ACLAction$outboundSchema).optional(),
   teamOwnMembership: z.array(ACLAction$outboundSchema).optional(),
   teamOwnMembershipDisconnectSAML: z.array(ACLAction$outboundSchema).optional(),
   token: z.array(ACLAction$outboundSchema).optional(),
@@ -6689,6 +7817,7 @@ export const UpdateProjectPermissions$outboundSchema: z.ZodType<
   deploymentCheckReRunFromProductionBranch: z.array(ACLAction$outboundSchema)
     .optional(),
   deploymentProductionGit: z.array(ACLAction$outboundSchema).optional(),
+  deploymentV0: z.array(ACLAction$outboundSchema).optional(),
   deploymentPreview: z.array(ACLAction$outboundSchema).optional(),
   deploymentPrivate: z.array(ACLAction$outboundSchema).optional(),
   deploymentPromote: z.array(ACLAction$outboundSchema).optional(),
@@ -6700,6 +7829,7 @@ export const UpdateProjectPermissions$outboundSchema: z.ZodType<
   optionsAllowlist: z.array(ACLAction$outboundSchema).optional(),
   job: z.array(ACLAction$outboundSchema).optional(),
   project: z.array(ACLAction$outboundSchema).optional(),
+  projectFromV0: z.array(ACLAction$outboundSchema).optional(),
   projectAccessGroup: z.array(ACLAction$outboundSchema).optional(),
   projectAnalyticsSampling: z.array(ACLAction$outboundSchema).optional(),
   projectDeploymentHook: z.array(ACLAction$outboundSchema).optional(),
@@ -6755,6 +7885,24 @@ export namespace UpdateProjectPermissions$ {
   export type Outbound = UpdateProjectPermissions$Outbound;
 }
 
+export function updateProjectPermissionsToJSON(
+  updateProjectPermissions: UpdateProjectPermissions,
+): string {
+  return JSON.stringify(
+    UpdateProjectPermissions$outboundSchema.parse(updateProjectPermissions),
+  );
+}
+
+export function updateProjectPermissionsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectPermissions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectPermissions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectPermissions' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectLastRollbackTarget$inboundSchema: z.ZodType<
   UpdateProjectLastRollbackTarget,
@@ -6785,6 +7933,26 @@ export namespace UpdateProjectLastRollbackTarget$ {
   export type Outbound = UpdateProjectLastRollbackTarget$Outbound;
 }
 
+export function updateProjectLastRollbackTargetToJSON(
+  updateProjectLastRollbackTarget: UpdateProjectLastRollbackTarget,
+): string {
+  return JSON.stringify(
+    UpdateProjectLastRollbackTarget$outboundSchema.parse(
+      updateProjectLastRollbackTarget,
+    ),
+  );
+}
+
+export function updateProjectLastRollbackTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLastRollbackTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLastRollbackTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLastRollbackTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectJobStatus$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectJobStatus
@@ -6878,6 +8046,26 @@ export namespace UpdateProjectLastAliasRequest$ {
   export type Outbound = UpdateProjectLastAliasRequest$Outbound;
 }
 
+export function updateProjectLastAliasRequestToJSON(
+  updateProjectLastAliasRequest: UpdateProjectLastAliasRequest,
+): string {
+  return JSON.stringify(
+    UpdateProjectLastAliasRequest$outboundSchema.parse(
+      updateProjectLastAliasRequest,
+    ),
+  );
+}
+
+export function updateProjectLastAliasRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectLastAliasRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectLastAliasRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectLastAliasRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectScope$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectScope
@@ -6941,6 +8129,26 @@ export namespace UpdateProjectProtectionBypass$ {
   export type Outbound = UpdateProjectProtectionBypass$Outbound;
 }
 
+export function updateProjectProtectionBypassToJSON(
+  updateProjectProtectionBypass: UpdateProjectProtectionBypass,
+): string {
+  return JSON.stringify(
+    UpdateProjectProtectionBypass$outboundSchema.parse(
+      updateProjectProtectionBypass,
+    ),
+  );
+}
+
+export function updateProjectProtectionBypassFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProtectionBypass, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectProtectionBypass$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProtectionBypass' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTrustedIpsProjectsDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectTrustedIpsProjectsDeploymentType> = z
@@ -7000,6 +8208,24 @@ export namespace UpdateProjectTrustedIps2$ {
   export type Outbound = UpdateProjectTrustedIps2$Outbound;
 }
 
+export function updateProjectTrustedIps2ToJSON(
+  updateProjectTrustedIps2: UpdateProjectTrustedIps2,
+): string {
+  return JSON.stringify(
+    UpdateProjectTrustedIps2$outboundSchema.parse(updateProjectTrustedIps2),
+  );
+}
+
+export function updateProjectTrustedIps2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTrustedIps2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTrustedIps2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTrustedIps2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTrustedIpsDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectTrustedIpsDeploymentType> = z.nativeEnum(
@@ -7063,6 +8289,26 @@ export namespace UpdateProjectTrustedIpsAddresses$ {
   export type Outbound = UpdateProjectTrustedIpsAddresses$Outbound;
 }
 
+export function updateProjectTrustedIpsAddressesToJSON(
+  updateProjectTrustedIpsAddresses: UpdateProjectTrustedIpsAddresses,
+): string {
+  return JSON.stringify(
+    UpdateProjectTrustedIpsAddresses$outboundSchema.parse(
+      updateProjectTrustedIpsAddresses,
+    ),
+  );
+}
+
+export function updateProjectTrustedIpsAddressesFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTrustedIpsAddresses, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTrustedIpsAddresses$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTrustedIpsAddresses' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTrustedIpsProtectionMode$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectTrustedIpsProtectionMode> = z.nativeEnum(
@@ -7133,6 +8379,24 @@ export namespace UpdateProjectTrustedIps1$ {
   export type Outbound = UpdateProjectTrustedIps1$Outbound;
 }
 
+export function updateProjectTrustedIps1ToJSON(
+  updateProjectTrustedIps1: UpdateProjectTrustedIps1,
+): string {
+  return JSON.stringify(
+    UpdateProjectTrustedIps1$outboundSchema.parse(updateProjectTrustedIps1),
+  );
+}
+
+export function updateProjectTrustedIps1FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTrustedIps1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTrustedIps1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTrustedIps1' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTrustedIps$inboundSchema: z.ZodType<
   UpdateProjectTrustedIps,
@@ -7171,6 +8435,24 @@ export namespace UpdateProjectTrustedIps$ {
   export type Outbound = UpdateProjectTrustedIps$Outbound;
 }
 
+export function updateProjectTrustedIpsToJSON(
+  updateProjectTrustedIps: UpdateProjectTrustedIps,
+): string {
+  return JSON.stringify(
+    UpdateProjectTrustedIps$outboundSchema.parse(updateProjectTrustedIps),
+  );
+}
+
+export function updateProjectTrustedIpsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectTrustedIps, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectTrustedIps$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectTrustedIps' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectGitComments$inboundSchema: z.ZodType<
   UpdateProjectGitComments,
@@ -7210,6 +8492,24 @@ export namespace UpdateProjectGitComments$ {
   export type Outbound = UpdateProjectGitComments$Outbound;
 }
 
+export function updateProjectGitCommentsToJSON(
+  updateProjectGitComments: UpdateProjectGitComments,
+): string {
+  return JSON.stringify(
+    UpdateProjectGitComments$outboundSchema.parse(updateProjectGitComments),
+  );
+}
+
+export function updateProjectGitCommentsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectGitComments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectGitComments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectGitComments' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectWebAnalytics$inboundSchema: z.ZodType<
   UpdateProjectWebAnalytics,
@@ -7258,6 +8558,24 @@ export namespace UpdateProjectWebAnalytics$ {
   export type Outbound = UpdateProjectWebAnalytics$Outbound;
 }
 
+export function updateProjectWebAnalyticsToJSON(
+  updateProjectWebAnalytics: UpdateProjectWebAnalytics,
+): string {
+  return JSON.stringify(
+    UpdateProjectWebAnalytics$outboundSchema.parse(updateProjectWebAnalytics),
+  );
+}
+
+export function updateProjectWebAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectWebAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectWebAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectWebAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectSrc2$inboundSchema: z.ZodType<
   UpdateProjectSrc2,
@@ -7324,6 +8642,24 @@ export namespace UpdateProjectSrc2$ {
   export type Outbound = UpdateProjectSrc2$Outbound;
 }
 
+export function updateProjectSrc2ToJSON(
+  updateProjectSrc2: UpdateProjectSrc2,
+): string {
+  return JSON.stringify(
+    UpdateProjectSrc2$outboundSchema.parse(updateProjectSrc2),
+  );
+}
+
+export function updateProjectSrc2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectSrc2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectSrc2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectSrc2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectSrc$inboundSchema: z.ZodType<
   UpdateProjectSrc,
@@ -7354,6 +8690,24 @@ export namespace UpdateProjectSrc$ {
   export type Outbound = UpdateProjectSrc$Outbound;
 }
 
+export function updateProjectSrcToJSON(
+  updateProjectSrc: UpdateProjectSrc,
+): string {
+  return JSON.stringify(
+    UpdateProjectSrc$outboundSchema.parse(updateProjectSrc),
+  );
+}
+
+export function updateProjectSrcFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectSrc, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectSrc$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectSrc' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponse200ApplicationJSONResponseBodySecurityType$inboundSchema:
   z.ZodNativeEnum<
@@ -7448,6 +8802,24 @@ export namespace UpdateProjectValue2$ {
   export type Outbound = UpdateProjectValue2$Outbound;
 }
 
+export function updateProjectValue2ToJSON(
+  updateProjectValue2: UpdateProjectValue2,
+): string {
+  return JSON.stringify(
+    UpdateProjectValue2$outboundSchema.parse(updateProjectValue2),
+  );
+}
+
+export function updateProjectValue2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectValue2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectValue2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectValue2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectValue$inboundSchema: z.ZodType<
   UpdateProjectValue,
@@ -7478,6 +8850,24 @@ export namespace UpdateProjectValue$ {
   export type Outbound = UpdateProjectValue$Outbound;
 }
 
+export function updateProjectValueToJSON(
+  updateProjectValue: UpdateProjectValue,
+): string {
+  return JSON.stringify(
+    UpdateProjectValue$outboundSchema.parse(updateProjectValue),
+  );
+}
+
+export function updateProjectValueFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectHas$inboundSchema: z.ZodType<
   UpdateProjectHas,
@@ -7524,6 +8914,24 @@ export namespace UpdateProjectHas$ {
   export type Outbound = UpdateProjectHas$Outbound;
 }
 
+export function updateProjectHasToJSON(
+  updateProjectHas: UpdateProjectHas,
+): string {
+  return JSON.stringify(
+    UpdateProjectHas$outboundSchema.parse(updateProjectHas),
+  );
+}
+
+export function updateProjectHasFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectHas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectHas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectHas' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$inboundSchema:
   z.ZodNativeEnum<
@@ -7618,6 +9026,26 @@ export namespace UpdateProjectValueProjects2$ {
   export type Outbound = UpdateProjectValueProjects2$Outbound;
 }
 
+export function updateProjectValueProjects2ToJSON(
+  updateProjectValueProjects2: UpdateProjectValueProjects2,
+): string {
+  return JSON.stringify(
+    UpdateProjectValueProjects2$outboundSchema.parse(
+      updateProjectValueProjects2,
+    ),
+  );
+}
+
+export function updateProjectValueProjects2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectValueProjects2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectValueProjects2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectValueProjects2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsValue$inboundSchema: z.ZodType<
   UpdateProjectProjectsValue,
@@ -7656,6 +9084,24 @@ export namespace UpdateProjectProjectsValue$ {
   export type Outbound = UpdateProjectProjectsValue$Outbound;
 }
 
+export function updateProjectProjectsValueToJSON(
+  updateProjectProjectsValue: UpdateProjectProjectsValue,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsValue$outboundSchema.parse(updateProjectProjectsValue),
+  );
+}
+
+export function updateProjectProjectsValueFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectProjectsValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectMissing$inboundSchema: z.ZodType<
   UpdateProjectMissing,
@@ -7706,6 +9152,24 @@ export namespace UpdateProjectMissing$ {
   export type Outbound = UpdateProjectMissing$Outbound;
 }
 
+export function updateProjectMissingToJSON(
+  updateProjectMissing: UpdateProjectMissing,
+): string {
+  return JSON.stringify(
+    UpdateProjectMissing$outboundSchema.parse(updateProjectMissing),
+  );
+}
+
+export function updateProjectMissingFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectMissing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectMissing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectMissing' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectHandle$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectHandle
@@ -7814,6 +9278,24 @@ export namespace UpdateProjectErl$ {
   export type Outbound = UpdateProjectErl$Outbound;
 }
 
+export function updateProjectErlToJSON(
+  updateProjectErl: UpdateProjectErl,
+): string {
+  return JSON.stringify(
+    UpdateProjectErl$outboundSchema.parse(updateProjectErl),
+  );
+}
+
+export function updateProjectErlFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectErl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectErl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectErl' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectMitigate$inboundSchema: z.ZodType<
   UpdateProjectMitigate,
@@ -7867,6 +9349,24 @@ export namespace UpdateProjectMitigate$ {
   export type Outbound = UpdateProjectMitigate$Outbound;
 }
 
+export function updateProjectMitigateToJSON(
+  updateProjectMitigate: UpdateProjectMitigate,
+): string {
+  return JSON.stringify(
+    UpdateProjectMitigate$outboundSchema.parse(updateProjectMitigate),
+  );
+}
+
+export function updateProjectMitigateFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectMitigate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectMitigate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectMitigate' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectFirewallRoutes$inboundSchema: z.ZodType<
   UpdateProjectFirewallRoutes,
@@ -7924,6 +9424,26 @@ export namespace UpdateProjectFirewallRoutes$ {
   export type Outbound = UpdateProjectFirewallRoutes$Outbound;
 }
 
+export function updateProjectFirewallRoutesToJSON(
+  updateProjectFirewallRoutes: UpdateProjectFirewallRoutes,
+): string {
+  return JSON.stringify(
+    UpdateProjectFirewallRoutes$outboundSchema.parse(
+      updateProjectFirewallRoutes,
+    ),
+  );
+}
+
+export function updateProjectFirewallRoutesFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectFirewallRoutes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectFirewallRoutes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectFirewallRoutes' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectSecurity$inboundSchema: z.ZodType<
   UpdateProjectSecurity,
@@ -7942,6 +9462,7 @@ export const UpdateProjectSecurity$inboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /** @internal */
@@ -7956,6 +9477,7 @@ export type UpdateProjectSecurity$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7976,6 +9498,7 @@ export const UpdateProjectSecurity$outboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /**
@@ -7991,6 +9514,24 @@ export namespace UpdateProjectSecurity$ {
   export type Outbound = UpdateProjectSecurity$Outbound;
 }
 
+export function updateProjectSecurityToJSON(
+  updateProjectSecurity: UpdateProjectSecurity,
+): string {
+  return JSON.stringify(
+    UpdateProjectSecurity$outboundSchema.parse(updateProjectSecurity),
+  );
+}
+
+export function updateProjectSecurityFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectSecurity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectSecurity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectSecurity' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectProjectsIssuerMode$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectProjectsIssuerMode
@@ -8053,6 +9594,27 @@ export namespace UpdateProjectProjectsOidcTokenConfig$ {
   export type Outbound = UpdateProjectProjectsOidcTokenConfig$Outbound;
 }
 
+export function updateProjectProjectsOidcTokenConfigToJSON(
+  updateProjectProjectsOidcTokenConfig: UpdateProjectProjectsOidcTokenConfig,
+): string {
+  return JSON.stringify(
+    UpdateProjectProjectsOidcTokenConfig$outboundSchema.parse(
+      updateProjectProjectsOidcTokenConfig,
+    ),
+  );
+}
+
+export function updateProjectProjectsOidcTokenConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectProjectsOidcTokenConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectProjectsOidcTokenConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectProjectsOidcTokenConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectTier$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectTier
@@ -8408,3 +9970,21 @@ export namespace UpdateProjectResponseBody$ {
   /** @deprecated use `UpdateProjectResponseBody$Outbound` instead. */
   export type Outbound = UpdateProjectResponseBody$Outbound;
 }
+
+export function updateProjectResponseBodyToJSON(
+  updateProjectResponseBody: UpdateProjectResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectResponseBody$outboundSchema.parse(updateProjectResponseBody),
+  );
+}
+
+export function updateProjectResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectResponseBody' from JSON`,
+  );
+}