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

package/src/models/operations/updateprojectdatacache.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";
 
 export type UpdateProjectDataCacheRequestBody = {
   /**
@@ -730,6 +733,29 @@ export type Link1 = {
 
 export type Link = Link1 | Link3 | Link2;
 
+export type Microfrontends = {
+  /**
+   * 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 UpdateProjectDataCacheNodeVersion = {
   TwentyTwoX: "22.x",
   TwentyX: "20.x",
@@ -1035,6 +1061,7 @@ export type Permissions = {
   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;
@@ -1064,6 +1091,7 @@ export type Permissions = {
   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;
@@ -1075,6 +1103,7 @@ export type Permissions = {
   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;
@@ -1375,6 +1404,7 @@ export type Security = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1434,6 +1464,7 @@ export type UpdateProjectDataCacheResponseBody = {
   ipBuckets?: Array<IpBuckets> | undefined;
   latestDeployments?: Array<LatestDeployments> | undefined;
   link?: Link1 | Link3 | Link2 | undefined;
+  microfrontends?: Microfrontends | undefined;
   name: string;
   nodeVersion: UpdateProjectDataCacheNodeVersion;
   optionsAllowlist?: UpdateProjectDataCacheOptionsAllowlist | null | undefined;
@@ -1517,6 +1548,26 @@ export namespace UpdateProjectDataCacheRequestBody$ {
   export type Outbound = UpdateProjectDataCacheRequestBody$Outbound;
 }
 
+export function updateProjectDataCacheRequestBodyToJSON(
+  updateProjectDataCacheRequestBody: UpdateProjectDataCacheRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheRequestBody$outboundSchema.parse(
+      updateProjectDataCacheRequestBody,
+    ),
+  );
+}
+
+export function updateProjectDataCacheRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheRequest$inboundSchema: z.ZodType<
   UpdateProjectDataCacheRequest,
@@ -1572,6 +1623,26 @@ export namespace UpdateProjectDataCacheRequest$ {
   export type Outbound = UpdateProjectDataCacheRequest$Outbound;
 }
 
+export function updateProjectDataCacheRequestToJSON(
+  updateProjectDataCacheRequest: UpdateProjectDataCacheRequest,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheRequest$outboundSchema.parse(
+      updateProjectDataCacheRequest,
+    ),
+  );
+}
+
+export function updateProjectDataCacheRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const Analytics$inboundSchema: z.ZodType<
   Analytics,
@@ -1626,6 +1697,20 @@ export namespace Analytics$ {
   export type Outbound = Analytics$Outbound;
 }
 
+export function analyticsToJSON(analytics: Analytics): string {
+  return JSON.stringify(Analytics$outboundSchema.parse(analytics));
+}
+
+export function analyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<Analytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Analytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Analytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const SpeedInsights$inboundSchema: z.ZodType<
   SpeedInsights,
@@ -1677,6 +1762,20 @@ export namespace SpeedInsights$ {
   export type Outbound = SpeedInsights$Outbound;
 }
 
+export function speedInsightsToJSON(speedInsights: SpeedInsights): string {
+  return JSON.stringify(SpeedInsights$outboundSchema.parse(speedInsights));
+}
+
+export function speedInsightsFromJSON(
+  jsonString: string,
+): SafeParseResult<SpeedInsights, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SpeedInsights$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SpeedInsights' from JSON`,
+  );
+}
+
 /** @internal */
 export const Definitions$inboundSchema: z.ZodType<
   Definitions,
@@ -1719,6 +1818,20 @@ export namespace Definitions$ {
   export type Outbound = Definitions$Outbound;
 }
 
+export function definitionsToJSON(definitions: Definitions): string {
+  return JSON.stringify(Definitions$outboundSchema.parse(definitions));
+}
+
+export function definitionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Definitions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Definitions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Definitions' from JSON`,
+  );
+}
+
 /** @internal */
 export const Crons$inboundSchema: z.ZodType<Crons, z.ZodTypeDef, unknown> = z
   .object({
@@ -1764,6 +1877,20 @@ export namespace Crons$ {
   export type Outbound = Crons$Outbound;
 }
 
+export function cronsToJSON(crons: Crons): string {
+  return JSON.stringify(Crons$outboundSchema.parse(crons));
+}
+
+export function cronsFromJSON(
+  jsonString: string,
+): SafeParseResult<Crons, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Crons$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Crons' from JSON`,
+  );
+}
+
 /** @internal */
 export const DataCache$inboundSchema: z.ZodType<
   DataCache,
@@ -1806,6 +1933,20 @@ export namespace DataCache$ {
   export type Outbound = DataCache$Outbound;
 }
 
+export function dataCacheToJSON(dataCache: DataCache): string {
+  return JSON.stringify(DataCache$outboundSchema.parse(dataCache));
+}
+
+export function dataCacheFromJSON(
+  jsonString: string,
+): SafeParseResult<DataCache, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataCache$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataCache' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeploymentExpiration$inboundSchema: z.ZodType<
   DeploymentExpiration,
@@ -1854,6 +1995,24 @@ export namespace DeploymentExpiration$ {
   export type Outbound = DeploymentExpiration$Outbound;
 }
 
+export function deploymentExpirationToJSON(
+  deploymentExpiration: DeploymentExpiration,
+): string {
+  return JSON.stringify(
+    DeploymentExpiration$outboundSchema.parse(deploymentExpiration),
+  );
+}
+
+export function deploymentExpirationFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentExpiration, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentExpiration$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentExpiration' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheTarget2$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheTarget2
@@ -1932,6 +2091,26 @@ export namespace UpdateProjectDataCacheTarget$ {
   export type Outbound = UpdateProjectDataCacheTarget$Outbound;
 }
 
+export function updateProjectDataCacheTargetToJSON(
+  updateProjectDataCacheTarget: UpdateProjectDataCacheTarget,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheTarget$outboundSchema.parse(
+      updateProjectDataCacheTarget,
+    ),
+  );
+}
+
+export function updateProjectDataCacheTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200Type> = z
@@ -2021,6 +2200,20 @@ export namespace Fifteen$ {
   export type Outbound = Fifteen$Outbound;
 }
 
+export function fifteenToJSON(fifteen: Fifteen): string {
+  return JSON.stringify(Fifteen$outboundSchema.parse(fifteen));
+}
+
+export function fifteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Fifteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fifteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fifteen' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2099,6 +2292,20 @@ export namespace Fourteen$ {
   export type Outbound = Fourteen$Outbound;
 }
 
+export function fourteenToJSON(fourteen: Fourteen): string {
+  return JSON.stringify(Fourteen$outboundSchema.parse(fourteen));
+}
+
+export function fourteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Fourteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fourteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fourteen' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2168,6 +2375,20 @@ export namespace Thirteen$ {
   export type Outbound = Thirteen$Outbound;
 }
 
+export function thirteenToJSON(thirteen: Thirteen): string {
+  return JSON.stringify(Thirteen$outboundSchema.parse(thirteen));
+}
+
+export function thirteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Thirteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Thirteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Thirteen' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2234,6 +2455,20 @@ export namespace Twelve$ {
   export type Outbound = Twelve$Outbound;
 }
 
+export function twelveToJSON(twelve: Twelve): string {
+  return JSON.stringify(Twelve$outboundSchema.parse(twelve));
+}
+
+export function twelveFromJSON(
+  jsonString: string,
+): SafeParseResult<Twelve, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Twelve$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Twelve' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2305,6 +2540,27 @@ export namespace UpdateProjectDataCacheContentHint11$ {
   export type Outbound = UpdateProjectDataCacheContentHint11$Outbound;
 }
 
+export function updateProjectDataCacheContentHint11ToJSON(
+  updateProjectDataCacheContentHint11: UpdateProjectDataCacheContentHint11,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheContentHint11$outboundSchema.parse(
+      updateProjectDataCacheContentHint11,
+    ),
+  );
+}
+
+export function updateProjectDataCacheContentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2374,6 +2630,20 @@ export namespace ContentHint10$ {
   export type Outbound = ContentHint10$Outbound;
 }
 
+export function contentHint10ToJSON(contentHint10: ContentHint10): string {
+  return JSON.stringify(ContentHint10$outboundSchema.parse(contentHint10));
+}
+
+export function contentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2443,6 +2713,20 @@ export namespace ContentHint9$ {
   export type Outbound = ContentHint9$Outbound;
 }
 
+export function contentHint9ToJSON(contentHint9: ContentHint9): string {
+  return JSON.stringify(ContentHint9$outboundSchema.parse(contentHint9));
+}
+
+export function contentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
   z.ZodNativeEnum<
@@ -2512,6 +2796,20 @@ export namespace ContentHint8$ {
   export type Outbound = ContentHint8$Outbound;
 }
 
+export function contentHint8ToJSON(contentHint8: ContentHint8): string {
+  return JSON.stringify(ContentHint8$outboundSchema.parse(contentHint8));
+}
+
+export function contentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -2581,6 +2879,20 @@ export namespace ContentHint7$ {
   export type Outbound = ContentHint7$Outbound;
 }
 
+export function contentHint7ToJSON(contentHint7: ContentHint7): string {
+  return JSON.stringify(ContentHint7$outboundSchema.parse(contentHint7));
+}
+
+export function contentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -2650,6 +2962,20 @@ export namespace ContentHint6$ {
   export type Outbound = ContentHint6$Outbound;
 }
 
+export function contentHint6ToJSON(contentHint6: ContentHint6): string {
+  return JSON.stringify(ContentHint6$outboundSchema.parse(contentHint6));
+}
+
+export function contentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2714,6 +3040,20 @@ export namespace ContentHint5$ {
   export type Outbound = ContentHint5$Outbound;
 }
 
+export function contentHint5ToJSON(contentHint5: ContentHint5): string {
+  return JSON.stringify(ContentHint5$outboundSchema.parse(contentHint5));
+}
+
+export function contentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<
@@ -2778,6 +3118,20 @@ export namespace ContentHint4$ {
   export type Outbound = ContentHint4$Outbound;
 }
 
+export function contentHint4ToJSON(contentHint4: ContentHint4): string {
+  return JSON.stringify(ContentHint4$outboundSchema.parse(contentHint4));
+}
+
+export function contentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsType> = z
@@ -2840,6 +3194,20 @@ export namespace ContentHint3$ {
   export type Outbound = ContentHint3$Outbound;
 }
 
+export function contentHint3ToJSON(contentHint3: ContentHint3): string {
+  return JSON.stringify(ContentHint3$outboundSchema.parse(contentHint3));
+}
+
+export function contentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheContentHintType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintType> = z.nativeEnum(
@@ -2903,6 +3271,20 @@ export namespace ContentHint2$ {
   export type Outbound = ContentHint2$Outbound;
 }
 
+export function contentHint2ToJSON(contentHint2: ContentHint2): string {
+  return JSON.stringify(ContentHint2$outboundSchema.parse(contentHint2));
+}
+
+export function contentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const ContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof ContentHintType
@@ -2963,6 +3345,20 @@ export namespace ContentHint1$ {
   export type Outbound = ContentHint1$Outbound;
 }
 
+export function contentHint1ToJSON(contentHint1: ContentHint1): string {
+  return JSON.stringify(ContentHint1$outboundSchema.parse(contentHint1));
+}
+
+export function contentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const ContentHint$inboundSchema: z.ZodType<
   ContentHint,
@@ -3040,6 +3436,20 @@ export namespace ContentHint$ {
   export type Outbound = ContentHint$Outbound;
 }
 
+export function contentHintToJSON(contentHint: ContentHint): string {
+  return JSON.stringify(ContentHint$outboundSchema.parse(contentHint));
+}
+
+export function contentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -3109,6 +3519,24 @@ export namespace InternalContentHint$ {
   export type Outbound = InternalContentHint$Outbound;
 }
 
+export function internalContentHintToJSON(
+  internalContentHint: InternalContentHint,
+): string {
+  return JSON.stringify(
+    InternalContentHint$outboundSchema.parse(internalContentHint),
+  );
+}
+
+export function internalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<InternalContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InternalContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const Env$inboundSchema: z.ZodType<Env, z.ZodTypeDef, unknown> = z
   .object({
@@ -3259,6 +3687,20 @@ export namespace Env$ {
   export type Outbound = Env$Outbound;
 }
 
+export function envToJSON(env: Env): string {
+  return JSON.stringify(Env$outboundSchema.parse(env));
+}
+
+export function envFromJSON(
+  jsonString: string,
+): SafeParseResult<Env, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Env$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Env' from JSON`,
+  );
+}
+
 /** @internal */
 export const CustomEnvironments$inboundSchema: z.ZodType<
   CustomEnvironments,
@@ -3289,6 +3731,24 @@ export namespace CustomEnvironments$ {
   export type Outbound = CustomEnvironments$Outbound;
 }
 
+export function customEnvironmentsToJSON(
+  customEnvironments: CustomEnvironments,
+): string {
+  return JSON.stringify(
+    CustomEnvironments$outboundSchema.parse(customEnvironments),
+  );
+}
+
+export function customEnvironmentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomEnvironments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomEnvironments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomEnvironments' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheFramework$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheFramework
@@ -3349,6 +3809,20 @@ export namespace IpBuckets$ {
   export type Outbound = IpBuckets$Outbound;
 }
 
+export function ipBucketsToJSON(ipBuckets: IpBuckets): string {
+  return JSON.stringify(IpBuckets$outboundSchema.parse(ipBuckets));
+}
+
+export function ipBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<IpBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IpBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IpBuckets' from JSON`,
+  );
+}
+
 /** @internal */
 export const AliasAssigned$inboundSchema: z.ZodType<
   AliasAssigned,
@@ -3379,6 +3853,20 @@ export namespace AliasAssigned$ {
   export type Outbound = AliasAssigned$Outbound;
 }
 
+export function aliasAssignedToJSON(aliasAssigned: AliasAssigned): string {
+  return JSON.stringify(AliasAssigned$outboundSchema.parse(aliasAssigned));
+}
+
+export function aliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<AliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsAliasError$inboundSchema: z.ZodType<
   UpdateProjectDataCacheProjectsAliasError,
@@ -3420,6 +3908,33 @@ export namespace UpdateProjectDataCacheProjectsAliasError$ {
   export type Outbound = UpdateProjectDataCacheProjectsAliasError$Outbound;
 }
 
+export function updateProjectDataCacheProjectsAliasErrorToJSON(
+  updateProjectDataCacheProjectsAliasError:
+    UpdateProjectDataCacheProjectsAliasError,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheProjectsAliasError$outboundSchema.parse(
+      updateProjectDataCacheProjectsAliasError,
+    ),
+  );
+}
+
+export function updateProjectDataCacheProjectsAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectDataCacheProjectsAliasError,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheProjectsAliasError$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectDataCacheProjectsAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -3489,6 +4004,20 @@ export namespace BranchMatcher$ {
   export type Outbound = BranchMatcher$Outbound;
 }
 
+export function branchMatcherToJSON(branchMatcher: BranchMatcher): string {
+  return JSON.stringify(BranchMatcher$outboundSchema.parse(branchMatcher));
+}
+
+export function branchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<BranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsBuilds$inboundSchema: z.ZodType<
   UpdateProjectDataCacheProjectsBuilds,
@@ -3533,6 +4062,27 @@ export namespace UpdateProjectDataCacheProjectsBuilds$ {
   export type Outbound = UpdateProjectDataCacheProjectsBuilds$Outbound;
 }
 
+export function updateProjectDataCacheProjectsBuildsToJSON(
+  updateProjectDataCacheProjectsBuilds: UpdateProjectDataCacheProjectsBuilds,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheProjectsBuilds$outboundSchema.parse(
+      updateProjectDataCacheProjectsBuilds,
+    ),
+  );
+}
+
+export function updateProjectDataCacheProjectsBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheProjectsBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheProjectsBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheProjectsBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsChecksConclusion$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsChecksConclusion> = z
@@ -3629,6 +4179,27 @@ export namespace UpdateProjectDataCacheProjectsCreator$ {
   export type Outbound = UpdateProjectDataCacheProjectsCreator$Outbound;
 }
 
+export function updateProjectDataCacheProjectsCreatorToJSON(
+  updateProjectDataCacheProjectsCreator: UpdateProjectDataCacheProjectsCreator,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheProjectsCreator$outboundSchema.parse(
+      updateProjectDataCacheProjectsCreator,
+    ),
+  );
+}
+
+export function updateProjectDataCacheProjectsCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheProjectsCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheProjectsCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheProjectsCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsOidcTokenClaims$inboundSchema:
   z.ZodType<
@@ -3703,6 +4274,33 @@ export namespace UpdateProjectDataCacheProjectsOidcTokenClaims$ {
   export type Outbound = UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound;
 }
 
+export function updateProjectDataCacheProjectsOidcTokenClaimsToJSON(
+  updateProjectDataCacheProjectsOidcTokenClaims:
+    UpdateProjectDataCacheProjectsOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheProjectsOidcTokenClaims$outboundSchema.parse(
+      updateProjectDataCacheProjectsOidcTokenClaims,
+    ),
+  );
+}
+
+export function updateProjectDataCacheProjectsOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectDataCacheProjectsOidcTokenClaims,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheProjectsOidcTokenClaims$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectDataCacheProjectsOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsPlan$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheProjectsPlan
@@ -3960,6 +4558,24 @@ export namespace LatestDeployments$ {
   export type Outbound = LatestDeployments$Outbound;
 }
 
+export function latestDeploymentsToJSON(
+  latestDeployments: LatestDeployments,
+): string {
+  return JSON.stringify(
+    LatestDeployments$outboundSchema.parse(latestDeployments),
+  );
+}
+
+export function latestDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<LatestDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LatestDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LatestDeployments' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheLinkProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheLinkProjectsType> = z.nativeEnum(
@@ -4034,6 +4650,27 @@ export namespace UpdateProjectDataCacheLinkDeployHooks$ {
   export type Outbound = UpdateProjectDataCacheLinkDeployHooks$Outbound;
 }
 
+export function updateProjectDataCacheLinkDeployHooksToJSON(
+  updateProjectDataCacheLinkDeployHooks: UpdateProjectDataCacheLinkDeployHooks,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheLinkDeployHooks$outboundSchema.parse(
+      updateProjectDataCacheLinkDeployHooks,
+    ),
+  );
+}
+
+export function updateProjectDataCacheLinkDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheLinkDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheLinkDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheLinkDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const Link3$inboundSchema: z.ZodType<Link3, z.ZodTypeDef, unknown> = z
   .object({
@@ -4104,6 +4741,20 @@ export namespace Link3$ {
   export type Outbound = Link3$Outbound;
 }
 
+export function link3ToJSON(link3: Link3): string {
+  return JSON.stringify(Link3$outboundSchema.parse(link3));
+}
+
+export function link3FromJSON(
+  jsonString: string,
+): SafeParseResult<Link3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Link3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Link3' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheLinkType$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheLinkType
@@ -4173,6 +4824,22 @@ export namespace LinkDeployHooks$ {
   export type Outbound = LinkDeployHooks$Outbound;
 }
 
+export function linkDeployHooksToJSON(
+  linkDeployHooks: LinkDeployHooks,
+): string {
+  return JSON.stringify(LinkDeployHooks$outboundSchema.parse(linkDeployHooks));
+}
+
+export function linkDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const Link2$inboundSchema: z.ZodType<Link2, z.ZodTypeDef, unknown> = z
   .object({
@@ -4242,6 +4909,20 @@ export namespace Link2$ {
   export type Outbound = Link2$Outbound;
 }
 
+export function link2ToJSON(link2: Link2): string {
+  return JSON.stringify(Link2$outboundSchema.parse(link2));
+}
+
+export function link2FromJSON(
+  jsonString: string,
+): SafeParseResult<Link2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Link2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Link2' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkType$inboundSchema: z.ZodNativeEnum<typeof LinkType> = z
   .nativeEnum(LinkType);
@@ -4309,6 +4990,20 @@ export namespace DeployHooks$ {
   export type Outbound = DeployHooks$Outbound;
 }
 
+export function deployHooksToJSON(deployHooks: DeployHooks): string {
+  return JSON.stringify(DeployHooks$outboundSchema.parse(deployHooks));
+}
+
+export function deployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<DeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const Link1$inboundSchema: z.ZodType<Link1, z.ZodTypeDef, unknown> = z
   .object({
@@ -4372,6 +5067,20 @@ export namespace Link1$ {
   export type Outbound = Link1$Outbound;
 }
 
+export function link1ToJSON(link1: Link1): string {
+  return JSON.stringify(Link1$outboundSchema.parse(link1));
+}
+
+export function link1FromJSON(
+  jsonString: string,
+): SafeParseResult<Link1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Link1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Link1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Link$inboundSchema: z.ZodType<Link, z.ZodTypeDef, unknown> = z
   .union([
@@ -4404,6 +5113,82 @@ export namespace Link$ {
   export type Outbound = Link$Outbound;
 }
 
+export function linkToJSON(link: Link): string {
+  return JSON.stringify(Link$outboundSchema.parse(link));
+}
+
+export function linkFromJSON(
+  jsonString: string,
+): SafeParseResult<Link, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Link$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Link' from JSON`,
+  );
+}
+
+/** @internal */
+export const Microfrontends$inboundSchema: z.ZodType<
+  Microfrontends,
+  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 Microfrontends$Outbound = {
+  updatedAt: number;
+  groupIds: Array<string>;
+  enabled: boolean;
+  isDefaultApp?: boolean | undefined;
+  defaultRoute?: string | undefined;
+};
+
+/** @internal */
+export const Microfrontends$outboundSchema: z.ZodType<
+  Microfrontends$Outbound,
+  z.ZodTypeDef,
+  Microfrontends
+> = 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 Microfrontends$ {
+  /** @deprecated use `Microfrontends$inboundSchema` instead. */
+  export const inboundSchema = Microfrontends$inboundSchema;
+  /** @deprecated use `Microfrontends$outboundSchema` instead. */
+  export const outboundSchema = Microfrontends$outboundSchema;
+  /** @deprecated use `Microfrontends$Outbound` instead. */
+  export type Outbound = Microfrontends$Outbound;
+}
+
+export function microfrontendsToJSON(microfrontends: Microfrontends): string {
+  return JSON.stringify(Microfrontends$outboundSchema.parse(microfrontends));
+}
+
+export function microfrontendsFromJSON(
+  jsonString: string,
+): SafeParseResult<Microfrontends, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Microfrontends$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Microfrontends' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheNodeVersion$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheNodeVersion
@@ -4462,6 +5247,26 @@ export namespace UpdateProjectDataCachePaths$ {
   export type Outbound = UpdateProjectDataCachePaths$Outbound;
 }
 
+export function updateProjectDataCachePathsToJSON(
+  updateProjectDataCachePaths: UpdateProjectDataCachePaths,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCachePaths$outboundSchema.parse(
+      updateProjectDataCachePaths,
+    ),
+  );
+}
+
+export function updateProjectDataCachePathsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCachePaths, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCachePaths$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCachePaths' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheOptionsAllowlist$inboundSchema: z.ZodType<
   UpdateProjectDataCacheOptionsAllowlist,
@@ -4500,6 +5305,28 @@ export namespace UpdateProjectDataCacheOptionsAllowlist$ {
   export type Outbound = UpdateProjectDataCacheOptionsAllowlist$Outbound;
 }
 
+export function updateProjectDataCacheOptionsAllowlistToJSON(
+  updateProjectDataCacheOptionsAllowlist:
+    UpdateProjectDataCacheOptionsAllowlist,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheOptionsAllowlist$outboundSchema.parse(
+      updateProjectDataCacheOptionsAllowlist,
+    ),
+  );
+}
+
+export function updateProjectDataCacheOptionsAllowlistFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheOptionsAllowlist, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheOptionsAllowlist$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheOptionsAllowlist' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCachePasswordProtection$inboundSchema: z.ZodType<
   UpdateProjectDataCachePasswordProtection,
@@ -4532,6 +5359,33 @@ export namespace UpdateProjectDataCachePasswordProtection$ {
   export type Outbound = UpdateProjectDataCachePasswordProtection$Outbound;
 }
 
+export function updateProjectDataCachePasswordProtectionToJSON(
+  updateProjectDataCachePasswordProtection:
+    UpdateProjectDataCachePasswordProtection,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCachePasswordProtection$outboundSchema.parse(
+      updateProjectDataCachePasswordProtection,
+    ),
+  );
+}
+
+export function updateProjectDataCachePasswordProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectDataCachePasswordProtection,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCachePasswordProtection$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectDataCachePasswordProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionDefaultMemoryType$inboundSchema: z.ZodNativeEnum<
   typeof FunctionDefaultMemoryType
@@ -4599,6 +5453,20 @@ export namespace ResourceConfig$ {
   export type Outbound = ResourceConfig$Outbound;
 }
 
+export function resourceConfigToJSON(resourceConfig: ResourceConfig): string {
+  return JSON.stringify(ResourceConfig$outboundSchema.parse(resourceConfig));
+}
+
+export function resourceConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<ResourceConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResourceConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResourceConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheDeploymentType> = z.nativeEnum(
@@ -4661,6 +5529,27 @@ export namespace UpdateProjectDataCacheSsoProtection$ {
   export type Outbound = UpdateProjectDataCacheSsoProtection$Outbound;
 }
 
+export function updateProjectDataCacheSsoProtectionToJSON(
+  updateProjectDataCacheSsoProtection: UpdateProjectDataCacheSsoProtection,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheSsoProtection$outboundSchema.parse(
+      updateProjectDataCacheSsoProtection,
+    ),
+  );
+}
+
+export function updateProjectDataCacheSsoProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheSsoProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheSsoProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheSsoProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheAliasAssigned$inboundSchema: z.ZodType<
   UpdateProjectDataCacheAliasAssigned,
@@ -4693,6 +5582,27 @@ export namespace UpdateProjectDataCacheAliasAssigned$ {
   export type Outbound = UpdateProjectDataCacheAliasAssigned$Outbound;
 }
 
+export function updateProjectDataCacheAliasAssignedToJSON(
+  updateProjectDataCacheAliasAssigned: UpdateProjectDataCacheAliasAssigned,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheAliasAssigned$outboundSchema.parse(
+      updateProjectDataCacheAliasAssigned,
+    ),
+  );
+}
+
+export function updateProjectDataCacheAliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheAliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheAliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheAliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheAliasError$inboundSchema: z.ZodType<
   UpdateProjectDataCacheAliasError,
@@ -4732,6 +5642,26 @@ export namespace UpdateProjectDataCacheAliasError$ {
   export type Outbound = UpdateProjectDataCacheAliasError$Outbound;
 }
 
+export function updateProjectDataCacheAliasErrorToJSON(
+  updateProjectDataCacheAliasError: UpdateProjectDataCacheAliasError,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheAliasError$outboundSchema.parse(
+      updateProjectDataCacheAliasError,
+    ),
+  );
+}
+
+export function updateProjectDataCacheAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheAliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheAliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$inboundSchema:
   z.ZodNativeEnum<
@@ -4803,6 +5733,27 @@ export namespace UpdateProjectDataCacheBranchMatcher$ {
   export type Outbound = UpdateProjectDataCacheBranchMatcher$Outbound;
 }
 
+export function updateProjectDataCacheBranchMatcherToJSON(
+  updateProjectDataCacheBranchMatcher: UpdateProjectDataCacheBranchMatcher,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheBranchMatcher$outboundSchema.parse(
+      updateProjectDataCacheBranchMatcher,
+    ),
+  );
+}
+
+export function updateProjectDataCacheBranchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheBranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheBranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheBranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheBuilds$inboundSchema: z.ZodType<
   UpdateProjectDataCacheBuilds,
@@ -4845,6 +5796,26 @@ export namespace UpdateProjectDataCacheBuilds$ {
   export type Outbound = UpdateProjectDataCacheBuilds$Outbound;
 }
 
+export function updateProjectDataCacheBuildsToJSON(
+  updateProjectDataCacheBuilds: UpdateProjectDataCacheBuilds,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheBuilds$outboundSchema.parse(
+      updateProjectDataCacheBuilds,
+    ),
+  );
+}
+
+export function updateProjectDataCacheBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheChecksConclusion$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheChecksConclusion> = z.nativeEnum(
@@ -4939,6 +5910,26 @@ export namespace UpdateProjectDataCacheCreator$ {
   export type Outbound = UpdateProjectDataCacheCreator$Outbound;
 }
 
+export function updateProjectDataCacheCreatorToJSON(
+  updateProjectDataCacheCreator: UpdateProjectDataCacheCreator,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheCreator$outboundSchema.parse(
+      updateProjectDataCacheCreator,
+    ),
+  );
+}
+
+export function updateProjectDataCacheCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheOidcTokenClaims$inboundSchema: z.ZodType<
   UpdateProjectDataCacheOidcTokenClaims,
@@ -5011,6 +6002,27 @@ export namespace UpdateProjectDataCacheOidcTokenClaims$ {
   export type Outbound = UpdateProjectDataCacheOidcTokenClaims$Outbound;
 }
 
+export function updateProjectDataCacheOidcTokenClaimsToJSON(
+  updateProjectDataCacheOidcTokenClaims: UpdateProjectDataCacheOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheOidcTokenClaims$outboundSchema.parse(
+      updateProjectDataCacheOidcTokenClaims,
+    ),
+  );
+}
+
+export function updateProjectDataCacheOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheOidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheOidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCachePlan$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCachePlan
@@ -5256,6 +6268,20 @@ export namespace Targets$ {
   export type Outbound = Targets$Outbound;
 }
 
+export function targetsToJSON(targets: Targets): string {
+  return JSON.stringify(Targets$outboundSchema.parse(targets));
+}
+
+export function targetsFromJSON(
+  jsonString: string,
+): SafeParseResult<Targets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Targets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Targets' from JSON`,
+  );
+}
+
 /** @internal */
 export const Permissions$inboundSchema: z.ZodType<
   Permissions,
@@ -5368,6 +6394,7 @@ export const Permissions$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(),
@@ -5398,6 +6425,7 @@ export const Permissions$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(),
@@ -5409,6 +6437,7 @@ export const Permissions$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(),
@@ -5557,6 +6586,7 @@ export type Permissions$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;
@@ -5586,6 +6616,7 @@ export type Permissions$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;
@@ -5597,6 +6628,7 @@ export type Permissions$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;
@@ -5746,6 +6778,7 @@ export const Permissions$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(),
@@ -5776,6 +6809,7 @@ export const Permissions$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(),
@@ -5787,6 +6821,7 @@ export const Permissions$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(),
@@ -5842,6 +6877,20 @@ export namespace Permissions$ {
   export type Outbound = Permissions$Outbound;
 }
 
+export function permissionsToJSON(permissions: Permissions): string {
+  return JSON.stringify(Permissions$outboundSchema.parse(permissions));
+}
+
+export function permissionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Permissions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Permissions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Permissions' from JSON`,
+  );
+}
+
 /** @internal */
 export const LastRollbackTarget$inboundSchema: z.ZodType<
   LastRollbackTarget,
@@ -5872,6 +6921,24 @@ export namespace LastRollbackTarget$ {
   export type Outbound = LastRollbackTarget$Outbound;
 }
 
+export function lastRollbackTargetToJSON(
+  lastRollbackTarget: LastRollbackTarget,
+): string {
+  return JSON.stringify(
+    LastRollbackTarget$outboundSchema.parse(lastRollbackTarget),
+  );
+}
+
+export function lastRollbackTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<LastRollbackTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LastRollbackTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LastRollbackTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const JobStatus$inboundSchema: z.ZodNativeEnum<typeof JobStatus> = z
   .nativeEnum(JobStatus);
@@ -5962,6 +7029,24 @@ export namespace LastAliasRequest$ {
   export type Outbound = LastAliasRequest$Outbound;
 }
 
+export function lastAliasRequestToJSON(
+  lastAliasRequest: LastAliasRequest,
+): string {
+  return JSON.stringify(
+    LastAliasRequest$outboundSchema.parse(lastAliasRequest),
+  );
+}
+
+export function lastAliasRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<LastAliasRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LastAliasRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LastAliasRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const Scope$inboundSchema: z.ZodNativeEnum<typeof Scope> = z.nativeEnum(
   Scope,
@@ -6024,6 +7109,24 @@ export namespace ProtectionBypass$ {
   export type Outbound = ProtectionBypass$Outbound;
 }
 
+export function protectionBypassToJSON(
+  protectionBypass: ProtectionBypass,
+): string {
+  return JSON.stringify(
+    ProtectionBypass$outboundSchema.parse(protectionBypass),
+  );
+}
+
+export function protectionBypassFromJSON(
+  jsonString: string,
+): SafeParseResult<ProtectionBypass, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProtectionBypass$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProtectionBypass' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheTrustedIpsDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsDeploymentType> = z
@@ -6083,6 +7186,20 @@ export namespace TrustedIps2$ {
   export type Outbound = TrustedIps2$Outbound;
 }
 
+export function trustedIps2ToJSON(trustedIps2: TrustedIps2): string {
+  return JSON.stringify(TrustedIps2$outboundSchema.parse(trustedIps2));
+}
+
+export function trustedIps2FromJSON(
+  jsonString: string,
+): SafeParseResult<TrustedIps2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrustedIps2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrustedIps2' from JSON`,
+  );
+}
+
 /** @internal */
 export const TrustedIpsDeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof TrustedIpsDeploymentType
@@ -6146,6 +7263,33 @@ export namespace UpdateProjectDataCacheTrustedIpsAddresses$ {
   export type Outbound = UpdateProjectDataCacheTrustedIpsAddresses$Outbound;
 }
 
+export function updateProjectDataCacheTrustedIpsAddressesToJSON(
+  updateProjectDataCacheTrustedIpsAddresses:
+    UpdateProjectDataCacheTrustedIpsAddresses,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheTrustedIpsAddresses$outboundSchema.parse(
+      updateProjectDataCacheTrustedIpsAddresses,
+    ),
+  );
+}
+
+export function updateProjectDataCacheTrustedIpsAddressesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  UpdateProjectDataCacheTrustedIpsAddresses,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheTrustedIpsAddresses$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'UpdateProjectDataCacheTrustedIpsAddresses' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheTrustedIpsProtectionMode$inboundSchema:
   z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsProtectionMode> = z
@@ -6215,6 +7359,20 @@ export namespace TrustedIps1$ {
   export type Outbound = TrustedIps1$Outbound;
 }
 
+export function trustedIps1ToJSON(trustedIps1: TrustedIps1): string {
+  return JSON.stringify(TrustedIps1$outboundSchema.parse(trustedIps1));
+}
+
+export function trustedIps1FromJSON(
+  jsonString: string,
+): SafeParseResult<TrustedIps1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrustedIps1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrustedIps1' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheTrustedIps$inboundSchema: z.ZodType<
   UpdateProjectDataCacheTrustedIps,
@@ -6253,6 +7411,26 @@ export namespace UpdateProjectDataCacheTrustedIps$ {
   export type Outbound = UpdateProjectDataCacheTrustedIps$Outbound;
 }
 
+export function updateProjectDataCacheTrustedIpsToJSON(
+  updateProjectDataCacheTrustedIps: UpdateProjectDataCacheTrustedIps,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheTrustedIps$outboundSchema.parse(
+      updateProjectDataCacheTrustedIps,
+    ),
+  );
+}
+
+export function updateProjectDataCacheTrustedIpsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheTrustedIps, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheTrustedIps$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheTrustedIps' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitComments$inboundSchema: z.ZodType<
   GitComments,
@@ -6292,6 +7470,20 @@ export namespace GitComments$ {
   export type Outbound = GitComments$Outbound;
 }
 
+export function gitCommentsToJSON(gitComments: GitComments): string {
+  return JSON.stringify(GitComments$outboundSchema.parse(gitComments));
+}
+
+export function gitCommentsFromJSON(
+  jsonString: string,
+): SafeParseResult<GitComments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitComments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitComments' from JSON`,
+  );
+}
+
 /** @internal */
 export const WebAnalytics$inboundSchema: z.ZodType<
   WebAnalytics,
@@ -6340,6 +7532,20 @@ export namespace WebAnalytics$ {
   export type Outbound = WebAnalytics$Outbound;
 }
 
+export function webAnalyticsToJSON(webAnalytics: WebAnalytics): string {
+  return JSON.stringify(WebAnalytics$outboundSchema.parse(webAnalytics));
+}
+
+export function webAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<WebAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WebAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WebAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const Src2$inboundSchema: z.ZodType<Src2, z.ZodTypeDef, unknown> = z
   .object({
@@ -6400,6 +7606,20 @@ export namespace Src2$ {
   export type Outbound = Src2$Outbound;
 }
 
+export function src2ToJSON(src2: Src2): string {
+  return JSON.stringify(Src2$outboundSchema.parse(src2));
+}
+
+export function src2FromJSON(
+  jsonString: string,
+): SafeParseResult<Src2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Src2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Src2' from JSON`,
+  );
+}
+
 /** @internal */
 export const Src$inboundSchema: z.ZodType<Src, z.ZodTypeDef, unknown> = z.union(
   [z.lazy(() => Src2$inboundSchema), z.string()],
@@ -6425,6 +7645,20 @@ export namespace Src$ {
   export type Outbound = Src$Outbound;
 }
 
+export function srcToJSON(src: Src): string {
+  return JSON.stringify(Src$outboundSchema.parse(src));
+}
+
+export function srcFromJSON(
+  jsonString: string,
+): SafeParseResult<Src, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Src$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Src' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$inboundSchema:
   z.ZodNativeEnum<
@@ -6521,6 +7755,27 @@ export namespace UpdateProjectDataCacheValueProjects2$ {
   export type Outbound = UpdateProjectDataCacheValueProjects2$Outbound;
 }
 
+export function updateProjectDataCacheValueProjects2ToJSON(
+  updateProjectDataCacheValueProjects2: UpdateProjectDataCacheValueProjects2,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheValueProjects2$outboundSchema.parse(
+      updateProjectDataCacheValueProjects2,
+    ),
+  );
+}
+
+export function updateProjectDataCacheValueProjects2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheValueProjects2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheValueProjects2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheValueProjects2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsValue$inboundSchema: z.ZodType<
   UpdateProjectDataCacheProjectsValue,
@@ -6561,6 +7816,27 @@ export namespace UpdateProjectDataCacheProjectsValue$ {
   export type Outbound = UpdateProjectDataCacheProjectsValue$Outbound;
 }
 
+export function updateProjectDataCacheProjectsValueToJSON(
+  updateProjectDataCacheProjectsValue: UpdateProjectDataCacheProjectsValue,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheProjectsValue$outboundSchema.parse(
+      updateProjectDataCacheProjectsValue,
+    ),
+  );
+}
+
+export function updateProjectDataCacheProjectsValueFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheProjectsValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheProjectsValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheProjectsValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const Has$inboundSchema: z.ZodType<Has, z.ZodTypeDef, unknown> = z
   .object({
@@ -6605,6 +7881,20 @@ export namespace Has$ {
   export type Outbound = Has$Outbound;
 }
 
+export function hasToJSON(has: Has): string {
+  return JSON.stringify(Has$outboundSchema.parse(has));
+}
+
+export function hasFromJSON(
+  jsonString: string,
+): SafeParseResult<Has, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Has$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Has' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$inboundSchema:
   z.ZodNativeEnum<
@@ -6699,6 +7989,26 @@ export namespace UpdateProjectDataCacheValue2$ {
   export type Outbound = UpdateProjectDataCacheValue2$Outbound;
 }
 
+export function updateProjectDataCacheValue2ToJSON(
+  updateProjectDataCacheValue2: UpdateProjectDataCacheValue2,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheValue2$outboundSchema.parse(
+      updateProjectDataCacheValue2,
+    ),
+  );
+}
+
+export function updateProjectDataCacheValue2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheValue2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheValue2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheValue2' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheValue$inboundSchema: z.ZodType<
   UpdateProjectDataCacheValue,
@@ -6737,6 +8047,26 @@ export namespace UpdateProjectDataCacheValue$ {
   export type Outbound = UpdateProjectDataCacheValue$Outbound;
 }
 
+export function updateProjectDataCacheValueToJSON(
+  updateProjectDataCacheValue: UpdateProjectDataCacheValue,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheValue$outboundSchema.parse(
+      updateProjectDataCacheValue,
+    ),
+  );
+}
+
+export function updateProjectDataCacheValueFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const Missing$inboundSchema: z.ZodType<Missing, z.ZodTypeDef, unknown> =
   z.object({
@@ -6784,6 +8114,20 @@ export namespace Missing$ {
   export type Outbound = Missing$Outbound;
 }
 
+export function missingToJSON(missing: Missing): string {
+  return JSON.stringify(Missing$outboundSchema.parse(missing));
+}
+
+export function missingFromJSON(
+  jsonString: string,
+): SafeParseResult<Missing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Missing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Missing' from JSON`,
+  );
+}
+
 /** @internal */
 export const Handle$inboundSchema: z.ZodNativeEnum<typeof Handle> = z
   .nativeEnum(Handle);
@@ -6884,6 +8228,20 @@ export namespace Erl$ {
   export type Outbound = Erl$Outbound;
 }
 
+export function erlToJSON(erl: Erl): string {
+  return JSON.stringify(Erl$outboundSchema.parse(erl));
+}
+
+export function erlFromJSON(
+  jsonString: string,
+): SafeParseResult<Erl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Erl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Erl' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheMitigate$inboundSchema: z.ZodType<
   UpdateProjectDataCacheMitigate,
@@ -6937,6 +8295,26 @@ export namespace UpdateProjectDataCacheMitigate$ {
   export type Outbound = UpdateProjectDataCacheMitigate$Outbound;
 }
 
+export function updateProjectDataCacheMitigateToJSON(
+  updateProjectDataCacheMitigate: UpdateProjectDataCacheMitigate,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheMitigate$outboundSchema.parse(
+      updateProjectDataCacheMitigate,
+    ),
+  );
+}
+
+export function updateProjectDataCacheMitigateFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheMitigate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateProjectDataCacheMitigate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheMitigate' from JSON`,
+  );
+}
+
 /** @internal */
 export const FirewallRoutes$inboundSchema: z.ZodType<
   FirewallRoutes,
@@ -6993,6 +8371,20 @@ export namespace FirewallRoutes$ {
   export type Outbound = FirewallRoutes$Outbound;
 }
 
+export function firewallRoutesToJSON(firewallRoutes: FirewallRoutes): string {
+  return JSON.stringify(FirewallRoutes$outboundSchema.parse(firewallRoutes));
+}
+
+export function firewallRoutesFromJSON(
+  jsonString: string,
+): SafeParseResult<FirewallRoutes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FirewallRoutes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FirewallRoutes' from JSON`,
+  );
+}
+
 /** @internal */
 export const Security$inboundSchema: z.ZodType<
   Security,
@@ -7010,6 +8402,7 @@ export const Security$inboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /** @internal */
@@ -7024,6 +8417,7 @@ export type Security$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7043,6 +8437,7 @@ export const Security$outboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /**
@@ -7058,6 +8453,20 @@ export namespace Security$ {
   export type Outbound = Security$Outbound;
 }
 
+export function securityToJSON(security: Security): string {
+  return JSON.stringify(Security$outboundSchema.parse(security));
+}
+
+export function securityFromJSON(
+  jsonString: string,
+): SafeParseResult<Security, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Security$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Security' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateProjectDataCacheIssuerMode$inboundSchema: z.ZodNativeEnum<
   typeof UpdateProjectDataCacheIssuerMode
@@ -7120,6 +8529,27 @@ export namespace UpdateProjectDataCacheOidcTokenConfig$ {
   export type Outbound = UpdateProjectDataCacheOidcTokenConfig$Outbound;
 }
 
+export function updateProjectDataCacheOidcTokenConfigToJSON(
+  updateProjectDataCacheOidcTokenConfig: UpdateProjectDataCacheOidcTokenConfig,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheOidcTokenConfig$outboundSchema.parse(
+      updateProjectDataCacheOidcTokenConfig,
+    ),
+  );
+}
+
+export function updateProjectDataCacheOidcTokenConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheOidcTokenConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheOidcTokenConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheOidcTokenConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const Tier$inboundSchema: z.ZodNativeEnum<typeof Tier> = z.nativeEnum(
   Tier,
@@ -7182,6 +8612,7 @@ export const UpdateProjectDataCacheResponseBody$inboundSchema: z.ZodType<
     z.lazy(() => Link3$inboundSchema),
     z.lazy(() => Link2$inboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => Microfrontends$inboundSchema).optional(),
   name: z.string(),
   nodeVersion: UpdateProjectDataCacheNodeVersion$inboundSchema,
   optionsAllowlist: z.nullable(
@@ -7270,6 +8701,7 @@ export type UpdateProjectDataCacheResponseBody$Outbound = {
   ipBuckets?: Array<IpBuckets$Outbound> | undefined;
   latestDeployments?: Array<LatestDeployments$Outbound> | undefined;
   link?: Link1$Outbound | Link3$Outbound | Link2$Outbound | undefined;
+  microfrontends?: Microfrontends$Outbound | undefined;
   name: string;
   nodeVersion: string;
   optionsAllowlist?:
@@ -7364,6 +8796,7 @@ export const UpdateProjectDataCacheResponseBody$outboundSchema: z.ZodType<
     z.lazy(() => Link3$outboundSchema),
     z.lazy(() => Link2$outboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => Microfrontends$outboundSchema).optional(),
   name: z.string(),
   nodeVersion: UpdateProjectDataCacheNodeVersion$outboundSchema,
   optionsAllowlist: z.nullable(
@@ -7437,3 +8870,24 @@ export namespace UpdateProjectDataCacheResponseBody$ {
   /** @deprecated use `UpdateProjectDataCacheResponseBody$Outbound` instead. */
   export type Outbound = UpdateProjectDataCacheResponseBody$Outbound;
 }
+
+export function updateProjectDataCacheResponseBodyToJSON(
+  updateProjectDataCacheResponseBody: UpdateProjectDataCacheResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateProjectDataCacheResponseBody$outboundSchema.parse(
+      updateProjectDataCacheResponseBody,
+    ),
+  );
+}
+
+export function updateProjectDataCacheResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateProjectDataCacheResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateProjectDataCacheResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateProjectDataCacheResponseBody' from JSON`,
+  );
+}