@vercel/sdk 14.0.0-canary.5 → 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
@@ -1041,6 +1044,29 @@ export type UpdateProjectLink =
   | UpdateProjectLink3
   | UpdateProjectLink2;
 
+export type UpdateProjectMicrofrontends = {
+  /**
+   * Timestamp when the microfrontends settings were last updated.
+   */
+  updatedAt: number;
+  /**
+   * 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.
+   */
+  groupIds: Array<string>;
+  /**
+   * Whether microfrontends are enabled for this project.
+   */
+  enabled: boolean;
+  /**
+   * Whether this project is the default application for the microfrontends group. The default application is the one that is used as the top level shell for the microfrontends group and hosts the other microfrontends.
+   */
+  isDefaultApp?: boolean | undefined;
+  /**
+   * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI.
+   */
+  defaultRoute?: string | undefined;
+};
+
 export const UpdateProjectProjectsNodeVersion = {
   TwentyTwoX: "22.x",
   TwentyX: "20.x",
@@ -1345,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;
@@ -1374,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;
@@ -1385,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;
@@ -1680,6 +1709,7 @@ export type UpdateProjectSecurity = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1746,6 +1776,7 @@ export type UpdateProjectResponseBody = {
     | UpdateProjectLink3
     | UpdateProjectLink2
     | undefined;
+  microfrontends?: UpdateProjectMicrofrontends | undefined;
   name: string;
   nodeVersion: UpdateProjectProjectsNodeVersion;
   optionsAllowlist?: UpdateProjectOptionsAllowlist | null | undefined;
@@ -1895,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
@@ -1955,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
@@ -2012,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
@@ -2074,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
@@ -2137,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({
@@ -2170,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,
@@ -2206,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,
@@ -2344,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,
@@ -2397,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,
@@ -2451,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,
@@ -2502,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,
@@ -2544,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,
@@ -2592,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,
@@ -2634,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,
@@ -2683,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
@@ -2734,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
@@ -2824,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<
@@ -2902,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<
@@ -2971,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<
@@ -3040,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<
@@ -3109,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<
@@ -3178,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<
@@ -3247,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<
@@ -3316,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<
@@ -3385,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<
@@ -3454,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<
@@ -3523,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
@@ -3585,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
@@ -3647,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(
@@ -3710,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
@@ -3770,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,
@@ -3847,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<
@@ -3916,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,
@@ -4071,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,
@@ -4101,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
@@ -4161,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,
@@ -4191,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,
@@ -4230,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<
@@ -4299,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,
@@ -4341,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
@@ -4431,6 +5174,24 @@ export namespace UpdateProjectCreator$ {
   export type Outbound = UpdateProjectCreator$Outbound;
 }
 
+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,
@@ -4501,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
@@ -4732,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(
@@ -4808,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,
@@ -4881,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
@@ -4952,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,
@@ -5028,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
@@ -5097,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,
@@ -5167,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,
@@ -5208,6 +6131,92 @@ export namespace UpdateProjectLink$ {
   export type Outbound = UpdateProjectLink$Outbound;
 }
 
+export function updateProjectLinkToJSON(
+  updateProjectLink: UpdateProjectLink,
+): string {
+  return JSON.stringify(
+    UpdateProjectLink$outboundSchema.parse(updateProjectLink),
+  );
+}
+
+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 */
+export const UpdateProjectMicrofrontends$inboundSchema: z.ZodType<
+  UpdateProjectMicrofrontends,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  updatedAt: z.number(),
+  groupIds: z.array(z.string()),
+  enabled: z.boolean(),
+  isDefaultApp: z.boolean().optional(),
+  defaultRoute: z.string().optional(),
+});
+
+/** @internal */
+export type UpdateProjectMicrofrontends$Outbound = {
+  updatedAt: number;
+  groupIds: Array<string>;
+  enabled: boolean;
+  isDefaultApp?: boolean | undefined;
+  defaultRoute?: string | undefined;
+};
+
+/** @internal */
+export const UpdateProjectMicrofrontends$outboundSchema: z.ZodType<
+  UpdateProjectMicrofrontends$Outbound,
+  z.ZodTypeDef,
+  UpdateProjectMicrofrontends
+> = z.object({
+  updatedAt: z.number(),
+  groupIds: z.array(z.string()),
+  enabled: z.boolean(),
+  isDefaultApp: z.boolean().optional(),
+  defaultRoute: z.string().optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateProjectMicrofrontends$ {
+  /** @deprecated use `UpdateProjectMicrofrontends$inboundSchema` instead. */
+  export const inboundSchema = UpdateProjectMicrofrontends$inboundSchema;
+  /** @deprecated use `UpdateProjectMicrofrontends$outboundSchema` instead. */
+  export const outboundSchema = UpdateProjectMicrofrontends$outboundSchema;
+  /** @deprecated use `UpdateProjectMicrofrontends$Outbound` instead. */
+  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
@@ -5265,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,
@@ -5301,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,
@@ -5331,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(
@@ -5402,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
@@ -5461,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,
@@ -5492,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,
@@ -5531,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> =
@@ -5594,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,
@@ -5636,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(
@@ -5729,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,
@@ -5801,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
@@ -6044,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,
@@ -6156,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(),
@@ -6186,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(),
@@ -6197,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(),
@@ -6345,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;
@@ -6374,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;
@@ -6385,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;
@@ -6534,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(),
@@ -6564,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(),
@@ -6575,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(),
@@ -6630,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,
@@ -6660,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
@@ -6753,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
@@ -6816,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
@@ -6875,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(
@@ -6938,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(
@@ -7008,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,
@@ -7046,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,
@@ -7085,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,
@@ -7133,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,
@@ -7199,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,
@@ -7229,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<
@@ -7323,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,
@@ -7353,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,
@@ -7399,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<
@@ -7493,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,
@@ -7531,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,
@@ -7581,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
@@ -7689,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,
@@ -7742,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,
@@ -7799,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,
@@ -7817,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 */
@@ -7831,6 +9477,7 @@ export type UpdateProjectSecurity$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7851,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(),
 });
 
 /**
@@ -7866,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
@@ -7928,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
@@ -7995,6 +9682,8 @@ export const UpdateProjectResponseBody$inboundSchema: z.ZodType<
     z.lazy(() => UpdateProjectLink3$inboundSchema),
     z.lazy(() => UpdateProjectLink2$inboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => UpdateProjectMicrofrontends$inboundSchema)
+    .optional(),
   name: z.string(),
   nodeVersion: UpdateProjectProjectsNodeVersion$inboundSchema,
   optionsAllowlist: z.nullable(
@@ -8100,6 +9789,7 @@ export type UpdateProjectResponseBody$Outbound = {
     | UpdateProjectLink3$Outbound
     | UpdateProjectLink2$Outbound
     | undefined;
+  microfrontends?: UpdateProjectMicrofrontends$Outbound | undefined;
   name: string;
   nodeVersion: string;
   optionsAllowlist?: UpdateProjectOptionsAllowlist$Outbound | null | undefined;
@@ -8201,6 +9891,8 @@ export const UpdateProjectResponseBody$outboundSchema: z.ZodType<
     z.lazy(() => UpdateProjectLink3$outboundSchema),
     z.lazy(() => UpdateProjectLink2$outboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => UpdateProjectMicrofrontends$outboundSchema)
+    .optional(),
   name: z.string(),
   nodeVersion: UpdateProjectProjectsNodeVersion$outboundSchema,
   optionsAllowlist: z.nullable(
@@ -8278,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`,
+  );
+}