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

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,29 +733,15 @@ export type Link1 = {
 
 export type Link = Link1 | Link3 | Link2;
 
-/**
- * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
- */
-export type Group = {
-  /**
-   * A unique identifier for the group of microfrontends. All related microfrontend projects will share this group ID. Example: mfe_12HKQaOmR5t5Uy6vdcQsNIiZgHGB
-   */
-  id: string;
-  /**
-   * A human readable name for the microfrontends group. This will be used to display the microfrontends group in the UI.
-   */
-  slug: string;
-};
-
 export type Microfrontends = {
   /**
    * Timestamp when the microfrontends settings were last updated.
    */
   updatedAt: number;
   /**
-   * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
+   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
    */
-  group: Group;
+  groupIds: Array<string>;
   /**
    * Whether microfrontends are enabled for this project.
    */
@@ -1039,6 +1028,7 @@ export type Permissions = {
   notificationCustomerBudget?: Array<ACLAction> | undefined;
   notificationStatementOfReasons?: Array<ACLAction> | undefined;
   oauth2Connection?: Array<ACLAction> | undefined;
+  observabilityConfiguration?: Array<ACLAction> | undefined;
   openTelemetryEndpoint?: Array<ACLAction> | undefined;
   paymentMethod?: Array<ACLAction> | undefined;
   permissions?: Array<ACLAction> | undefined;
@@ -1072,6 +1062,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;
@@ -1101,6 +1092,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;
@@ -1111,7 +1103,9 @@ export type Permissions = {
   passwordProtection?: Array<ACLAction> | undefined;
   optionsAllowlist?: Array<ACLAction> | undefined;
   job?: Array<ACLAction> | undefined;
+  observabilityData?: Array<ACLAction> | undefined;
   project?: Array<ACLAction> | undefined;
+  projectFromV0?: Array<ACLAction> | undefined;
   projectAccessGroup?: Array<ACLAction> | undefined;
   projectAnalyticsSampling?: Array<ACLAction> | undefined;
   projectDeploymentHook?: Array<ACLAction> | undefined;
@@ -1412,6 +1406,7 @@ export type Security = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1555,6 +1550,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,
@@ -1610,6 +1625,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,
@@ -1664,6 +1699,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,
@@ -1715,6 +1764,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,
@@ -1757,6 +1820,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({
@@ -1802,6 +1879,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,
@@ -1844,6 +1935,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,
@@ -1892,6 +1997,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
@@ -1970,6 +2093,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
@@ -2059,6 +2202,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<
@@ -2137,6 +2294,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<
@@ -2206,6 +2377,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<
@@ -2272,6 +2457,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<
@@ -2343,6 +2542,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<
@@ -2412,6 +2632,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<
@@ -2481,6 +2715,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<
@@ -2550,6 +2798,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<
@@ -2619,6 +2881,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<
@@ -2688,6 +2964,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<
@@ -2752,6 +3042,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<
@@ -2816,6 +3120,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
@@ -2878,6 +3196,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(
@@ -2941,6 +3273,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
@@ -3001,6 +3347,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,
@@ -3078,6 +3438,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<
@@ -3147,6 +3521,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({
@@ -3297,6 +3689,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,
@@ -3327,6 +3733,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
@@ -3387,6 +3811,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,
@@ -3417,6 +3855,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,
@@ -3458,6 +3910,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<
@@ -3527,6 +4006,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,
@@ -3571,6 +4064,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
@@ -3667,6 +4181,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<
@@ -3741,6 +4276,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
@@ -3998,6 +4560,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(
@@ -4072,6 +4652,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({
@@ -4142,6 +4743,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
@@ -4211,6 +4826,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({
@@ -4280,6 +4911,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);
@@ -4347,6 +4992,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({
@@ -4410,6 +5069,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([
@@ -4442,40 +5115,18 @@ export namespace Link$ {
   export type Outbound = Link$Outbound;
 }
 
-/** @internal */
-export const Group$inboundSchema: z.ZodType<Group, z.ZodTypeDef, unknown> = z
-  .object({
-    id: z.string(),
-    slug: z.string(),
-  });
-
-/** @internal */
-export type Group$Outbound = {
-  id: string;
-  slug: string;
-};
-
-/** @internal */
-export const Group$outboundSchema: z.ZodType<
-  Group$Outbound,
-  z.ZodTypeDef,
-  Group
-> = z.object({
-  id: z.string(),
-  slug: z.string(),
-});
+export function linkToJSON(link: Link): string {
+  return JSON.stringify(Link$outboundSchema.parse(link));
+}
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Group$ {
-  /** @deprecated use `Group$inboundSchema` instead. */
-  export const inboundSchema = Group$inboundSchema;
-  /** @deprecated use `Group$outboundSchema` instead. */
-  export const outboundSchema = Group$outboundSchema;
-  /** @deprecated use `Group$Outbound` instead. */
-  export type Outbound = Group$Outbound;
+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 */
@@ -4485,7 +5136,7 @@ export const Microfrontends$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => Group$inboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -4494,7 +5145,7 @@ export const Microfrontends$inboundSchema: z.ZodType<
 /** @internal */
 export type Microfrontends$Outbound = {
   updatedAt: number;
-  group: Group$Outbound;
+  groupIds: Array<string>;
   enabled: boolean;
   isDefaultApp?: boolean | undefined;
   defaultRoute?: string | undefined;
@@ -4507,7 +5158,7 @@ export const Microfrontends$outboundSchema: z.ZodType<
   Microfrontends
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => Group$outboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -4526,6 +5177,20 @@ export namespace Microfrontends$ {
   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
@@ -4584,6 +5249,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,
@@ -4622,6 +5307,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,
@@ -4654,6 +5361,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
@@ -4721,6 +5455,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(
@@ -4783,6 +5531,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,
@@ -4815,6 +5584,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,
@@ -4854,6 +5644,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<
@@ -4925,6 +5735,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,
@@ -4967,6 +5798,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(
@@ -5061,6 +5912,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,
@@ -5133,6 +6004,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
@@ -5378,6 +6270,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,
@@ -5457,6 +6363,7 @@ export const Permissions$inboundSchema: z.ZodType<
   notificationCustomerBudget: z.array(ACLAction$inboundSchema).optional(),
   notificationStatementOfReasons: z.array(ACLAction$inboundSchema).optional(),
   oauth2Connection: z.array(ACLAction$inboundSchema).optional(),
+  observabilityConfiguration: z.array(ACLAction$inboundSchema).optional(),
   openTelemetryEndpoint: z.array(ACLAction$inboundSchema).optional(),
   paymentMethod: z.array(ACLAction$inboundSchema).optional(),
   permissions: z.array(ACLAction$inboundSchema).optional(),
@@ -5490,6 +6397,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(),
@@ -5520,6 +6428,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(),
@@ -5530,7 +6439,9 @@ export const Permissions$inboundSchema: z.ZodType<
   passwordProtection: z.array(ACLAction$inboundSchema).optional(),
   optionsAllowlist: z.array(ACLAction$inboundSchema).optional(),
   job: z.array(ACLAction$inboundSchema).optional(),
+  observabilityData: 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(),
@@ -5646,6 +6557,7 @@ export type Permissions$Outbound = {
   notificationCustomerBudget?: Array<string> | undefined;
   notificationStatementOfReasons?: Array<string> | undefined;
   oauth2Connection?: Array<string> | undefined;
+  observabilityConfiguration?: Array<string> | undefined;
   openTelemetryEndpoint?: Array<string> | undefined;
   paymentMethod?: Array<string> | undefined;
   permissions?: Array<string> | undefined;
@@ -5679,6 +6591,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;
@@ -5708,6 +6621,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;
@@ -5718,7 +6632,9 @@ export type Permissions$Outbound = {
   passwordProtection?: Array<string> | undefined;
   optionsAllowlist?: Array<string> | undefined;
   job?: Array<string> | undefined;
+  observabilityData?: Array<string> | undefined;
   project?: Array<string> | undefined;
+  projectFromV0?: Array<string> | undefined;
   projectAccessGroup?: Array<string> | undefined;
   projectAnalyticsSampling?: Array<string> | undefined;
   projectDeploymentHook?: Array<string> | undefined;
@@ -5835,6 +6751,7 @@ export const Permissions$outboundSchema: z.ZodType<
   notificationCustomerBudget: z.array(ACLAction$outboundSchema).optional(),
   notificationStatementOfReasons: z.array(ACLAction$outboundSchema).optional(),
   oauth2Connection: z.array(ACLAction$outboundSchema).optional(),
+  observabilityConfiguration: z.array(ACLAction$outboundSchema).optional(),
   openTelemetryEndpoint: z.array(ACLAction$outboundSchema).optional(),
   paymentMethod: z.array(ACLAction$outboundSchema).optional(),
   permissions: z.array(ACLAction$outboundSchema).optional(),
@@ -5868,6 +6785,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(),
@@ -5898,6 +6816,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(),
@@ -5908,7 +6827,9 @@ export const Permissions$outboundSchema: z.ZodType<
   passwordProtection: z.array(ACLAction$outboundSchema).optional(),
   optionsAllowlist: z.array(ACLAction$outboundSchema).optional(),
   job: z.array(ACLAction$outboundSchema).optional(),
+  observabilityData: 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(),
@@ -5964,6 +6885,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,
@@ -5994,6 +6929,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);
@@ -6084,6 +7037,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,
@@ -6146,6 +7117,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
@@ -6205,6 +7194,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
@@ -6268,6 +7271,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
@@ -6337,6 +7367,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,
@@ -6375,6 +7419,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,
@@ -6414,6 +7478,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,
@@ -6462,6 +7540,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({
@@ -6522,6 +7614,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()],
@@ -6547,6 +7653,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<
@@ -6643,6 +7763,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,
@@ -6683,6 +7824,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({
@@ -6727,6 +7889,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<
@@ -6821,6 +7997,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,
@@ -6859,6 +8055,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({
@@ -6906,6 +8122,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);
@@ -7006,6 +8236,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,
@@ -7059,6 +8303,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,
@@ -7115,6 +8379,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,
@@ -7132,6 +8410,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 */
@@ -7146,6 +8425,7 @@ export type Security$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7165,6 +8445,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(),
 });
 
 /**
@@ -7180,6 +8461,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
@@ -7242,6 +8537,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,
@@ -7562,3 +8878,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`,
+  );
+}