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

package/src/models/operations/createproject.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 const Target2 = {
   Production: "production",
@@ -943,6 +946,29 @@ export type CreateProjectLink =
   | CreateProjectLink3
   | CreateProjectLink2;
 
+export type CreateProjectMicrofrontends = {
+  /**
+   * 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 CreateProjectNodeVersion = {
   TwentyTwoX: "22.x",
   TwentyX: "20.x",
@@ -1249,6 +1275,7 @@ export type CreateProjectPermissions = {
   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;
@@ -1278,6 +1305,7 @@ export type CreateProjectPermissions = {
   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;
@@ -1289,6 +1317,7 @@ export type CreateProjectPermissions = {
   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;
@@ -1585,6 +1614,7 @@ export type CreateProjectSecurity = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1651,6 +1681,7 @@ export type CreateProjectResponseBody = {
     | CreateProjectLink3
     | CreateProjectLink2
     | undefined;
+  microfrontends?: CreateProjectMicrofrontends | undefined;
   name: string;
   nodeVersion: CreateProjectNodeVersion;
   optionsAllowlist?: CreateProjectOptionsAllowlist | null | undefined;
@@ -1766,6 +1797,24 @@ export namespace CreateProjectTarget$ {
   export type Outbound = CreateProjectTarget$Outbound;
 }
 
+export function createProjectTargetToJSON(
+  createProjectTarget: CreateProjectTarget,
+): string {
+  return JSON.stringify(
+    CreateProjectTarget$outboundSchema.parse(createProjectTarget),
+  );
+}
+
+export function createProjectTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectType
@@ -1835,6 +1884,24 @@ export namespace EnvironmentVariables$ {
   export type Outbound = EnvironmentVariables$Outbound;
 }
 
+export function environmentVariablesToJSON(
+  environmentVariables: EnvironmentVariables,
+): string {
+  return JSON.stringify(
+    EnvironmentVariables$outboundSchema.parse(environmentVariables),
+  );
+}
+
+export function environmentVariablesFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvironmentVariables, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvironmentVariables$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvironmentVariables' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectFramework$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectFramework
@@ -1916,6 +1983,20 @@ export namespace GitRepository$ {
   export type Outbound = GitRepository$Outbound;
 }
 
+export function gitRepositoryToJSON(gitRepository: GitRepository): string {
+  return JSON.stringify(GitRepository$outboundSchema.parse(gitRepository));
+}
+
+export function gitRepositoryFromJSON(
+  jsonString: string,
+): SafeParseResult<GitRepository, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitRepository$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitRepository' from JSON`,
+  );
+}
+
 /** @internal */
 export const IssuerMode$inboundSchema: z.ZodNativeEnum<typeof IssuerMode> = z
   .nativeEnum(IssuerMode);
@@ -1974,6 +2055,22 @@ export namespace OidcTokenConfig$ {
   export type Outbound = OidcTokenConfig$Outbound;
 }
 
+export function oidcTokenConfigToJSON(
+  oidcTokenConfig: OidcTokenConfig,
+): string {
+  return JSON.stringify(OidcTokenConfig$outboundSchema.parse(oidcTokenConfig));
+}
+
+export function oidcTokenConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<OidcTokenConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OidcTokenConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OidcTokenConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectRequestBody$inboundSchema: z.ZodType<
   CreateProjectRequestBody,
@@ -2059,6 +2156,24 @@ export namespace CreateProjectRequestBody$ {
   export type Outbound = CreateProjectRequestBody$Outbound;
 }
 
+export function createProjectRequestBodyToJSON(
+  createProjectRequestBody: CreateProjectRequestBody,
+): string {
+  return JSON.stringify(
+    CreateProjectRequestBody$outboundSchema.parse(createProjectRequestBody),
+  );
+}
+
+export function createProjectRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectRequest$inboundSchema: z.ZodType<
   CreateProjectRequest,
@@ -2109,6 +2224,24 @@ export namespace CreateProjectRequest$ {
   export type Outbound = CreateProjectRequest$Outbound;
 }
 
+export function createProjectRequestToJSON(
+  createProjectRequest: CreateProjectRequest,
+): string {
+  return JSON.stringify(
+    CreateProjectRequest$outboundSchema.parse(createProjectRequest),
+  );
+}
+
+export function createProjectRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectAnalytics$inboundSchema: z.ZodType<
   CreateProjectAnalytics,
@@ -2163,6 +2296,24 @@ export namespace CreateProjectAnalytics$ {
   export type Outbound = CreateProjectAnalytics$Outbound;
 }
 
+export function createProjectAnalyticsToJSON(
+  createProjectAnalytics: CreateProjectAnalytics,
+): string {
+  return JSON.stringify(
+    CreateProjectAnalytics$outboundSchema.parse(createProjectAnalytics),
+  );
+}
+
+export function createProjectAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectSpeedInsights$inboundSchema: z.ZodType<
   CreateProjectSpeedInsights,
@@ -2214,6 +2365,24 @@ export namespace CreateProjectSpeedInsights$ {
   export type Outbound = CreateProjectSpeedInsights$Outbound;
 }
 
+export function createProjectSpeedInsightsToJSON(
+  createProjectSpeedInsights: CreateProjectSpeedInsights,
+): string {
+  return JSON.stringify(
+    CreateProjectSpeedInsights$outboundSchema.parse(createProjectSpeedInsights),
+  );
+}
+
+export function createProjectSpeedInsightsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectSpeedInsights, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectSpeedInsights$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectSpeedInsights' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectDefinitions$inboundSchema: z.ZodType<
   CreateProjectDefinitions,
@@ -2256,6 +2425,24 @@ export namespace CreateProjectDefinitions$ {
   export type Outbound = CreateProjectDefinitions$Outbound;
 }
 
+export function createProjectDefinitionsToJSON(
+  createProjectDefinitions: CreateProjectDefinitions,
+): string {
+  return JSON.stringify(
+    CreateProjectDefinitions$outboundSchema.parse(createProjectDefinitions),
+  );
+}
+
+export function createProjectDefinitionsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectDefinitions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectDefinitions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectDefinitions' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectCrons$inboundSchema: z.ZodType<
   CreateProjectCrons,
@@ -2304,6 +2491,24 @@ export namespace CreateProjectCrons$ {
   export type Outbound = CreateProjectCrons$Outbound;
 }
 
+export function createProjectCronsToJSON(
+  createProjectCrons: CreateProjectCrons,
+): string {
+  return JSON.stringify(
+    CreateProjectCrons$outboundSchema.parse(createProjectCrons),
+  );
+}
+
+export function createProjectCronsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectCrons, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectCrons$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectCrons' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectDataCache$inboundSchema: z.ZodType<
   CreateProjectDataCache,
@@ -2346,6 +2551,24 @@ export namespace CreateProjectDataCache$ {
   export type Outbound = CreateProjectDataCache$Outbound;
 }
 
+export function createProjectDataCacheToJSON(
+  createProjectDataCache: CreateProjectDataCache,
+): string {
+  return JSON.stringify(
+    CreateProjectDataCache$outboundSchema.parse(createProjectDataCache),
+  );
+}
+
+export function createProjectDataCacheFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectDataCache, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectDataCache$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectDataCache' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectDeploymentExpiration$inboundSchema: z.ZodType<
   CreateProjectDeploymentExpiration,
@@ -2395,6 +2618,26 @@ export namespace CreateProjectDeploymentExpiration$ {
   export type Outbound = CreateProjectDeploymentExpiration$Outbound;
 }
 
+export function createProjectDeploymentExpirationToJSON(
+  createProjectDeploymentExpiration: CreateProjectDeploymentExpiration,
+): string {
+  return JSON.stringify(
+    CreateProjectDeploymentExpiration$outboundSchema.parse(
+      createProjectDeploymentExpiration,
+    ),
+  );
+}
+
+export function createProjectDeploymentExpirationFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectDeploymentExpiration, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectDeploymentExpiration$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectDeploymentExpiration' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectTarget2$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectTarget2
@@ -2446,6 +2689,26 @@ export namespace CreateProjectProjectsTarget$ {
   export type Outbound = CreateProjectProjectsTarget$Outbound;
 }
 
+export function createProjectProjectsTargetToJSON(
+  createProjectProjectsTarget: CreateProjectProjectsTarget,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsTarget$outboundSchema.parse(
+      createProjectProjectsTarget,
+    ),
+  );
+}
+
+export function createProjectProjectsTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProjectsTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponseType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectProjectsResponseType
@@ -2537,6 +2800,20 @@ export namespace ContentHint15$ {
   export type Outbound = ContentHint15$Outbound;
 }
 
+export function contentHint15ToJSON(contentHint15: ContentHint15): string {
+  return JSON.stringify(ContentHint15$outboundSchema.parse(contentHint15));
+}
+
+export function contentHint15FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint15' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2615,6 +2892,20 @@ export namespace ContentHint14$ {
   export type Outbound = ContentHint14$Outbound;
 }
 
+export function contentHint14ToJSON(contentHint14: ContentHint14): string {
+  return JSON.stringify(ContentHint14$outboundSchema.parse(contentHint14));
+}
+
+export function contentHint14FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint14' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2684,6 +2975,20 @@ export namespace ContentHint13$ {
   export type Outbound = ContentHint13$Outbound;
 }
 
+export function contentHint13ToJSON(contentHint13: ContentHint13): string {
+  return JSON.stringify(ContentHint13$outboundSchema.parse(contentHint13));
+}
+
+export function contentHint13FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint13' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2753,6 +3058,20 @@ export namespace ContentHint12$ {
   export type Outbound = ContentHint12$Outbound;
 }
 
+export function contentHint12ToJSON(contentHint12: ContentHint12): string {
+  return JSON.stringify(ContentHint12$outboundSchema.parse(contentHint12));
+}
+
+export function contentHint12FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint12' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2822,6 +3141,20 @@ export namespace ContentHint11$ {
   export type Outbound = ContentHint11$Outbound;
 }
 
+export function contentHint11ToJSON(contentHint11: ContentHint11): string {
+  return JSON.stringify(ContentHint11$outboundSchema.parse(contentHint11));
+}
+
+export function contentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<ContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2891,6 +3224,24 @@ export namespace CreateProjectContentHint10$ {
   export type Outbound = CreateProjectContentHint10$Outbound;
 }
 
+export function createProjectContentHint10ToJSON(
+  createProjectContentHint10: CreateProjectContentHint10,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint10$outboundSchema.parse(createProjectContentHint10),
+  );
+}
+
+export function createProjectContentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2960,6 +3311,24 @@ export namespace CreateProjectContentHint9$ {
   export type Outbound = CreateProjectContentHint9$Outbound;
 }
 
+export function createProjectContentHint9ToJSON(
+  createProjectContentHint9: CreateProjectContentHint9,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint9$outboundSchema.parse(createProjectContentHint9),
+  );
+}
+
+export function createProjectContentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnv8Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3029,6 +3398,24 @@ export namespace CreateProjectContentHint8$ {
   export type Outbound = CreateProjectContentHint8$Outbound;
 }
 
+export function createProjectContentHint8ToJSON(
+  createProjectContentHint8: CreateProjectContentHint8,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint8$outboundSchema.parse(createProjectContentHint8),
+  );
+}
+
+export function createProjectContentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
   z.ZodNativeEnum<
@@ -3098,6 +3485,24 @@ export namespace CreateProjectContentHint7$ {
   export type Outbound = CreateProjectContentHint7$Outbound;
 }
 
+export function createProjectContentHint7ToJSON(
+  createProjectContentHint7: CreateProjectContentHint7,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint7$outboundSchema.parse(createProjectContentHint7),
+  );
+}
+
+export function createProjectContentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -3167,6 +3572,24 @@ export namespace CreateProjectContentHint6$ {
   export type Outbound = CreateProjectContentHint6$Outbound;
 }
 
+export function createProjectContentHint6ToJSON(
+  createProjectContentHint6: CreateProjectContentHint6,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint6$outboundSchema.parse(createProjectContentHint6),
+  );
+}
+
+export function createProjectContentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -3236,6 +3659,24 @@ export namespace CreateProjectContentHint5$ {
   export type Outbound = CreateProjectContentHint5$Outbound;
 }
 
+export function createProjectContentHint5ToJSON(
+  createProjectContentHint5: CreateProjectContentHint5,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint5$outboundSchema.parse(createProjectContentHint5),
+  );
+}
+
+export function createProjectContentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectContentHintProjectsResponse200Type> = z
@@ -3298,6 +3739,24 @@ export namespace CreateProjectContentHint4$ {
   export type Outbound = CreateProjectContentHint4$Outbound;
 }
 
+export function createProjectContentHint4ToJSON(
+  createProjectContentHint4: CreateProjectContentHint4,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint4$outboundSchema.parse(createProjectContentHint4),
+  );
+}
+
+export function createProjectContentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectContentHintProjectsResponseType> = z
@@ -3360,6 +3819,24 @@ export namespace CreateProjectContentHint3$ {
   export type Outbound = CreateProjectContentHint3$Outbound;
 }
 
+export function createProjectContentHint3ToJSON(
+  createProjectContentHint3: CreateProjectContentHint3,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint3$outboundSchema.parse(createProjectContentHint3),
+  );
+}
+
+export function createProjectContentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectContentHintProjectsType> = z.nativeEnum(
@@ -3423,6 +3900,24 @@ export namespace CreateProjectContentHint2$ {
   export type Outbound = CreateProjectContentHint2$Outbound;
 }
 
+export function createProjectContentHint2ToJSON(
+  createProjectContentHint2: CreateProjectContentHint2,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint2$outboundSchema.parse(createProjectContentHint2),
+  );
+}
+
+export function createProjectContentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectContentHintType
@@ -3483,6 +3978,24 @@ export namespace CreateProjectContentHint1$ {
   export type Outbound = CreateProjectContentHint1$Outbound;
 }
 
+export function createProjectContentHint1ToJSON(
+  createProjectContentHint1: CreateProjectContentHint1,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint1$outboundSchema.parse(createProjectContentHint1),
+  );
+}
+
+export function createProjectContentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectContentHint$inboundSchema: z.ZodType<
   CreateProjectContentHint,
@@ -3560,6 +4073,24 @@ export namespace CreateProjectContentHint$ {
   export type Outbound = CreateProjectContentHint$Outbound;
 }
 
+export function createProjectContentHintToJSON(
+  createProjectContentHint: CreateProjectContentHint,
+): string {
+  return JSON.stringify(
+    CreateProjectContentHint$outboundSchema.parse(createProjectContentHint),
+  );
+}
+
+export function createProjectContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
   z.ZodNativeEnum<
@@ -3629,6 +4160,26 @@ export namespace CreateProjectInternalContentHint$ {
   export type Outbound = CreateProjectInternalContentHint$Outbound;
 }
 
+export function createProjectInternalContentHintToJSON(
+  createProjectInternalContentHint: CreateProjectInternalContentHint,
+): string {
+  return JSON.stringify(
+    CreateProjectInternalContentHint$outboundSchema.parse(
+      createProjectInternalContentHint,
+    ),
+  );
+}
+
+export function createProjectInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectInternalContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectInternalContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnv$inboundSchema: z.ZodType<
   CreateProjectEnv,
@@ -3784,6 +4335,24 @@ export namespace CreateProjectEnv$ {
   export type Outbound = CreateProjectEnv$Outbound;
 }
 
+export function createProjectEnvToJSON(
+  createProjectEnv: CreateProjectEnv,
+): string {
+  return JSON.stringify(
+    CreateProjectEnv$outboundSchema.parse(createProjectEnv),
+  );
+}
+
+export function createProjectEnvFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnv, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnv$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnv' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectCustomEnvironments$inboundSchema: z.ZodType<
   CreateProjectCustomEnvironments,
@@ -3814,6 +4383,26 @@ export namespace CreateProjectCustomEnvironments$ {
   export type Outbound = CreateProjectCustomEnvironments$Outbound;
 }
 
+export function createProjectCustomEnvironmentsToJSON(
+  createProjectCustomEnvironments: CreateProjectCustomEnvironments,
+): string {
+  return JSON.stringify(
+    CreateProjectCustomEnvironments$outboundSchema.parse(
+      createProjectCustomEnvironments,
+    ),
+  );
+}
+
+export function createProjectCustomEnvironmentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectCustomEnvironments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectCustomEnvironments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectCustomEnvironments' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsFramework$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectProjectsFramework
@@ -3874,6 +4463,24 @@ export namespace CreateProjectIpBuckets$ {
   export type Outbound = CreateProjectIpBuckets$Outbound;
 }
 
+export function createProjectIpBucketsToJSON(
+  createProjectIpBuckets: CreateProjectIpBuckets,
+): string {
+  return JSON.stringify(
+    CreateProjectIpBuckets$outboundSchema.parse(createProjectIpBuckets),
+  );
+}
+
+export function createProjectIpBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectIpBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectIpBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectIpBuckets' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectAliasAssigned$inboundSchema: z.ZodType<
   CreateProjectAliasAssigned,
@@ -3904,6 +4511,24 @@ export namespace CreateProjectAliasAssigned$ {
   export type Outbound = CreateProjectAliasAssigned$Outbound;
 }
 
+export function createProjectAliasAssignedToJSON(
+  createProjectAliasAssigned: CreateProjectAliasAssigned,
+): string {
+  return JSON.stringify(
+    CreateProjectAliasAssigned$outboundSchema.parse(createProjectAliasAssigned),
+  );
+}
+
+export function createProjectAliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectAliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectAliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectAliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectAliasError$inboundSchema: z.ZodType<
   CreateProjectAliasError,
@@ -3943,6 +4568,24 @@ export namespace CreateProjectAliasError$ {
   export type Outbound = CreateProjectAliasError$Outbound;
 }
 
+export function createProjectAliasErrorToJSON(
+  createProjectAliasError: CreateProjectAliasError,
+): string {
+  return JSON.stringify(
+    CreateProjectAliasError$outboundSchema.parse(createProjectAliasError),
+  );
+}
+
+export function createProjectAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectAliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectAliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponse200ApplicationJSONResponseBodyLatestDeploymentsType$inboundSchema:
   z.ZodNativeEnum<
@@ -4012,6 +4655,24 @@ export namespace CreateProjectBranchMatcher$ {
   export type Outbound = CreateProjectBranchMatcher$Outbound;
 }
 
+export function createProjectBranchMatcherToJSON(
+  createProjectBranchMatcher: CreateProjectBranchMatcher,
+): string {
+  return JSON.stringify(
+    CreateProjectBranchMatcher$outboundSchema.parse(createProjectBranchMatcher),
+  );
+}
+
+export function createProjectBranchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectBranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectBranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectBranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectBuilds$inboundSchema: z.ZodType<
   CreateProjectBuilds,
@@ -4054,6 +4715,24 @@ export namespace CreateProjectBuilds$ {
   export type Outbound = CreateProjectBuilds$Outbound;
 }
 
+export function createProjectBuildsToJSON(
+  createProjectBuilds: CreateProjectBuilds,
+): string {
+  return JSON.stringify(
+    CreateProjectBuilds$outboundSchema.parse(createProjectBuilds),
+  );
+}
+
+export function createProjectBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectChecksConclusion$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectChecksConclusion
@@ -4144,6 +4823,24 @@ export namespace CreateProjectCreator$ {
   export type Outbound = CreateProjectCreator$Outbound;
 }
 
+export function createProjectCreatorToJSON(
+  createProjectCreator: CreateProjectCreator,
+): string {
+  return JSON.stringify(
+    CreateProjectCreator$outboundSchema.parse(createProjectCreator),
+  );
+}
+
+export function createProjectCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectOidcTokenClaims$inboundSchema: z.ZodType<
   CreateProjectOidcTokenClaims,
@@ -4214,6 +4911,26 @@ export namespace CreateProjectOidcTokenClaims$ {
   export type Outbound = CreateProjectOidcTokenClaims$Outbound;
 }
 
+export function createProjectOidcTokenClaimsToJSON(
+  createProjectOidcTokenClaims: CreateProjectOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    CreateProjectOidcTokenClaims$outboundSchema.parse(
+      createProjectOidcTokenClaims,
+    ),
+  );
+}
+
+export function createProjectOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectOidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectOidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectPlan$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectPlan
@@ -4448,6 +5165,26 @@ export namespace CreateProjectLatestDeployments$ {
   export type Outbound = CreateProjectLatestDeployments$Outbound;
 }
 
+export function createProjectLatestDeploymentsToJSON(
+  createProjectLatestDeployments: CreateProjectLatestDeployments,
+): string {
+  return JSON.stringify(
+    CreateProjectLatestDeployments$outboundSchema.parse(
+      createProjectLatestDeployments,
+    ),
+  );
+}
+
+export function createProjectLatestDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLatestDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLatestDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLatestDeployments' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLinkProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectLinkProjectsResponseType> = z.nativeEnum(
@@ -4524,6 +5261,33 @@ export namespace CreateProjectLinkProjectsResponseDeployHooks$ {
   export type Outbound = CreateProjectLinkProjectsResponseDeployHooks$Outbound;
 }
 
+export function createProjectLinkProjectsResponseDeployHooksToJSON(
+  createProjectLinkProjectsResponseDeployHooks:
+    CreateProjectLinkProjectsResponseDeployHooks,
+): string {
+  return JSON.stringify(
+    CreateProjectLinkProjectsResponseDeployHooks$outboundSchema.parse(
+      createProjectLinkProjectsResponseDeployHooks,
+    ),
+  );
+}
+
+export function createProjectLinkProjectsResponseDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateProjectLinkProjectsResponseDeployHooks,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectLinkProjectsResponseDeployHooks$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateProjectLinkProjectsResponseDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLink3$inboundSchema: z.ZodType<
   CreateProjectLink3,
@@ -4597,8 +5361,26 @@ export namespace CreateProjectLink3$ {
   export type Outbound = CreateProjectLink3$Outbound;
 }
 
-/** @internal */
-export const CreateProjectLinkProjectsType$inboundSchema: z.ZodNativeEnum<
+export function createProjectLink3ToJSON(
+  createProjectLink3: CreateProjectLink3,
+): string {
+  return JSON.stringify(
+    CreateProjectLink3$outboundSchema.parse(createProjectLink3),
+  );
+}
+
+export function createProjectLink3FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLink3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLink3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLink3' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectLinkProjectsType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectLinkProjectsType
 > = z.nativeEnum(CreateProjectLinkProjectsType);
 
@@ -4668,6 +5450,27 @@ export namespace CreateProjectLinkProjectsDeployHooks$ {
   export type Outbound = CreateProjectLinkProjectsDeployHooks$Outbound;
 }
 
+export function createProjectLinkProjectsDeployHooksToJSON(
+  createProjectLinkProjectsDeployHooks: CreateProjectLinkProjectsDeployHooks,
+): string {
+  return JSON.stringify(
+    CreateProjectLinkProjectsDeployHooks$outboundSchema.parse(
+      createProjectLinkProjectsDeployHooks,
+    ),
+  );
+}
+
+export function createProjectLinkProjectsDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLinkProjectsDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectLinkProjectsDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLinkProjectsDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLink2$inboundSchema: z.ZodType<
   CreateProjectLink2,
@@ -4744,6 +5547,24 @@ export namespace CreateProjectLink2$ {
   export type Outbound = CreateProjectLink2$Outbound;
 }
 
+export function createProjectLink2ToJSON(
+  createProjectLink2: CreateProjectLink2,
+): string {
+  return JSON.stringify(
+    CreateProjectLink2$outboundSchema.parse(createProjectLink2),
+  );
+}
+
+export function createProjectLink2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLink2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLink2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLink2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLinkType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectLinkType
@@ -4813,6 +5634,26 @@ export namespace CreateProjectLinkDeployHooks$ {
   export type Outbound = CreateProjectLinkDeployHooks$Outbound;
 }
 
+export function createProjectLinkDeployHooksToJSON(
+  createProjectLinkDeployHooks: CreateProjectLinkDeployHooks,
+): string {
+  return JSON.stringify(
+    CreateProjectLinkDeployHooks$outboundSchema.parse(
+      createProjectLinkDeployHooks,
+    ),
+  );
+}
+
+export function createProjectLinkDeployHooksFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLinkDeployHooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLinkDeployHooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLinkDeployHooks' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLink1$inboundSchema: z.ZodType<
   CreateProjectLink1,
@@ -4883,6 +5724,24 @@ export namespace CreateProjectLink1$ {
   export type Outbound = CreateProjectLink1$Outbound;
 }
 
+export function createProjectLink1ToJSON(
+  createProjectLink1: CreateProjectLink1,
+): string {
+  return JSON.stringify(
+    CreateProjectLink1$outboundSchema.parse(createProjectLink1),
+  );
+}
+
+export function createProjectLink1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLink1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLink1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLink1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLink$inboundSchema: z.ZodType<
   CreateProjectLink,
@@ -4924,6 +5783,92 @@ export namespace CreateProjectLink$ {
   export type Outbound = CreateProjectLink$Outbound;
 }
 
+export function createProjectLinkToJSON(
+  createProjectLink: CreateProjectLink,
+): string {
+  return JSON.stringify(
+    CreateProjectLink$outboundSchema.parse(createProjectLink),
+  );
+}
+
+export function createProjectLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLink' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectMicrofrontends$inboundSchema: z.ZodType<
+  CreateProjectMicrofrontends,
+  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 CreateProjectMicrofrontends$Outbound = {
+  updatedAt: number;
+  groupIds: Array<string>;
+  enabled: boolean;
+  isDefaultApp?: boolean | undefined;
+  defaultRoute?: string | undefined;
+};
+
+/** @internal */
+export const CreateProjectMicrofrontends$outboundSchema: z.ZodType<
+  CreateProjectMicrofrontends$Outbound,
+  z.ZodTypeDef,
+  CreateProjectMicrofrontends
+> = 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 CreateProjectMicrofrontends$ {
+  /** @deprecated use `CreateProjectMicrofrontends$inboundSchema` instead. */
+  export const inboundSchema = CreateProjectMicrofrontends$inboundSchema;
+  /** @deprecated use `CreateProjectMicrofrontends$outboundSchema` instead. */
+  export const outboundSchema = CreateProjectMicrofrontends$outboundSchema;
+  /** @deprecated use `CreateProjectMicrofrontends$Outbound` instead. */
+  export type Outbound = CreateProjectMicrofrontends$Outbound;
+}
+
+export function createProjectMicrofrontendsToJSON(
+  createProjectMicrofrontends: CreateProjectMicrofrontends,
+): string {
+  return JSON.stringify(
+    CreateProjectMicrofrontends$outboundSchema.parse(
+      createProjectMicrofrontends,
+    ),
+  );
+}
+
+export function createProjectMicrofrontendsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectMicrofrontends, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectMicrofrontends$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectMicrofrontends' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectNodeVersion$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectNodeVersion
@@ -4981,6 +5926,24 @@ export namespace CreateProjectPaths$ {
   export type Outbound = CreateProjectPaths$Outbound;
 }
 
+export function createProjectPathsToJSON(
+  createProjectPaths: CreateProjectPaths,
+): string {
+  return JSON.stringify(
+    CreateProjectPaths$outboundSchema.parse(createProjectPaths),
+  );
+}
+
+export function createProjectPathsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectPaths, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectPaths$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectPaths' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectOptionsAllowlist$inboundSchema: z.ZodType<
   CreateProjectOptionsAllowlist,
@@ -5017,6 +5980,26 @@ export namespace CreateProjectOptionsAllowlist$ {
   export type Outbound = CreateProjectOptionsAllowlist$Outbound;
 }
 
+export function createProjectOptionsAllowlistToJSON(
+  createProjectOptionsAllowlist: CreateProjectOptionsAllowlist,
+): string {
+  return JSON.stringify(
+    CreateProjectOptionsAllowlist$outboundSchema.parse(
+      createProjectOptionsAllowlist,
+    ),
+  );
+}
+
+export function createProjectOptionsAllowlistFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectOptionsAllowlist, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectOptionsAllowlist$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectOptionsAllowlist' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectPasswordProtection$inboundSchema: z.ZodType<
   CreateProjectPasswordProtection,
@@ -5047,6 +6030,26 @@ export namespace CreateProjectPasswordProtection$ {
   export type Outbound = CreateProjectPasswordProtection$Outbound;
 }
 
+export function createProjectPasswordProtectionToJSON(
+  createProjectPasswordProtection: CreateProjectPasswordProtection,
+): string {
+  return JSON.stringify(
+    CreateProjectPasswordProtection$outboundSchema.parse(
+      createProjectPasswordProtection,
+    ),
+  );
+}
+
+export function createProjectPasswordProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectPasswordProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectPasswordProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectPasswordProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectFunctionDefaultMemoryType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectFunctionDefaultMemoryType> = z.nativeEnum(
@@ -5118,6 +6121,26 @@ export namespace CreateProjectResourceConfig$ {
   export type Outbound = CreateProjectResourceConfig$Outbound;
 }
 
+export function createProjectResourceConfigToJSON(
+  createProjectResourceConfig: CreateProjectResourceConfig,
+): string {
+  return JSON.stringify(
+    CreateProjectResourceConfig$outboundSchema.parse(
+      createProjectResourceConfig,
+    ),
+  );
+}
+
+export function createProjectResourceConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectResourceConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectResourceConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectResourceConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectDeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectDeploymentType
@@ -5175,6 +6198,24 @@ export namespace CreateProjectSsoProtection$ {
   export type Outbound = CreateProjectSsoProtection$Outbound;
 }
 
+export function createProjectSsoProtectionToJSON(
+  createProjectSsoProtection: CreateProjectSsoProtection,
+): string {
+  return JSON.stringify(
+    CreateProjectSsoProtection$outboundSchema.parse(createProjectSsoProtection),
+  );
+}
+
+export function createProjectSsoProtectionFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectSsoProtection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectSsoProtection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectSsoProtection' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsAliasAssigned$inboundSchema: z.ZodType<
   CreateProjectProjectsAliasAssigned,
@@ -5206,6 +6247,27 @@ export namespace CreateProjectProjectsAliasAssigned$ {
   export type Outbound = CreateProjectProjectsAliasAssigned$Outbound;
 }
 
+export function createProjectProjectsAliasAssignedToJSON(
+  createProjectProjectsAliasAssigned: CreateProjectProjectsAliasAssigned,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsAliasAssigned$outboundSchema.parse(
+      createProjectProjectsAliasAssigned,
+    ),
+  );
+}
+
+export function createProjectProjectsAliasAssignedFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsAliasAssigned, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectProjectsAliasAssigned$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsAliasAssigned' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsAliasError$inboundSchema: z.ZodType<
   CreateProjectProjectsAliasError,
@@ -5245,6 +6307,26 @@ export namespace CreateProjectProjectsAliasError$ {
   export type Outbound = CreateProjectProjectsAliasError$Outbound;
 }
 
+export function createProjectProjectsAliasErrorToJSON(
+  createProjectProjectsAliasError: CreateProjectProjectsAliasError,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsAliasError$outboundSchema.parse(
+      createProjectProjectsAliasError,
+    ),
+  );
+}
+
+export function createProjectProjectsAliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsAliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProjectsAliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsAliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponse200ApplicationJSONResponseBodyTargetsType$inboundSchema:
   z.ZodNativeEnum<
@@ -5315,6 +6397,27 @@ export namespace CreateProjectProjectsBranchMatcher$ {
   export type Outbound = CreateProjectProjectsBranchMatcher$Outbound;
 }
 
+export function createProjectProjectsBranchMatcherToJSON(
+  createProjectProjectsBranchMatcher: CreateProjectProjectsBranchMatcher,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsBranchMatcher$outboundSchema.parse(
+      createProjectProjectsBranchMatcher,
+    ),
+  );
+}
+
+export function createProjectProjectsBranchMatcherFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsBranchMatcher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectProjectsBranchMatcher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsBranchMatcher' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsBuilds$inboundSchema: z.ZodType<
   CreateProjectProjectsBuilds,
@@ -5357,6 +6460,26 @@ export namespace CreateProjectProjectsBuilds$ {
   export type Outbound = CreateProjectProjectsBuilds$Outbound;
 }
 
+export function createProjectProjectsBuildsToJSON(
+  createProjectProjectsBuilds: CreateProjectProjectsBuilds,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsBuilds$outboundSchema.parse(
+      createProjectProjectsBuilds,
+    ),
+  );
+}
+
+export function createProjectProjectsBuildsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsBuilds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProjectsBuilds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsBuilds' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsChecksConclusion$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectProjectsChecksConclusion> = z.nativeEnum(
@@ -5450,6 +6573,26 @@ export namespace CreateProjectProjectsCreator$ {
   export type Outbound = CreateProjectProjectsCreator$Outbound;
 }
 
+export function createProjectProjectsCreatorToJSON(
+  createProjectProjectsCreator: CreateProjectProjectsCreator,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsCreator$outboundSchema.parse(
+      createProjectProjectsCreator,
+    ),
+  );
+}
+
+export function createProjectProjectsCreatorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsCreator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProjectsCreator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsCreator' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsOidcTokenClaims$inboundSchema: z.ZodType<
   CreateProjectProjectsOidcTokenClaims,
@@ -5522,6 +6665,27 @@ export namespace CreateProjectProjectsOidcTokenClaims$ {
   export type Outbound = CreateProjectProjectsOidcTokenClaims$Outbound;
 }
 
+export function createProjectProjectsOidcTokenClaimsToJSON(
+  createProjectProjectsOidcTokenClaims: CreateProjectProjectsOidcTokenClaims,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsOidcTokenClaims$outboundSchema.parse(
+      createProjectProjectsOidcTokenClaims,
+    ),
+  );
+}
+
+export function createProjectProjectsOidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsOidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectProjectsOidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsOidcTokenClaims' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsPlan$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectProjectsPlan
@@ -5766,6 +6930,24 @@ export namespace CreateProjectTargets$ {
   export type Outbound = CreateProjectTargets$Outbound;
 }
 
+export function createProjectTargetsToJSON(
+  createProjectTargets: CreateProjectTargets,
+): string {
+  return JSON.stringify(
+    CreateProjectTargets$outboundSchema.parse(createProjectTargets),
+  );
+}
+
+export function createProjectTargetsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectTargets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectTargets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectTargets' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectPermissions$inboundSchema: z.ZodType<
   CreateProjectPermissions,
@@ -5878,6 +7060,7 @@ export const CreateProjectPermissions$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(),
@@ -5908,6 +7091,7 @@ export const CreateProjectPermissions$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(),
@@ -5919,6 +7103,7 @@ export const CreateProjectPermissions$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(),
@@ -6067,6 +7252,7 @@ export type CreateProjectPermissions$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;
@@ -6096,6 +7282,7 @@ export type CreateProjectPermissions$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;
@@ -6107,6 +7294,7 @@ export type CreateProjectPermissions$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;
@@ -6256,6 +7444,7 @@ export const CreateProjectPermissions$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(),
@@ -6286,6 +7475,7 @@ export const CreateProjectPermissions$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(),
@@ -6297,6 +7487,7 @@ export const CreateProjectPermissions$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(),
@@ -6352,6 +7543,24 @@ export namespace CreateProjectPermissions$ {
   export type Outbound = CreateProjectPermissions$Outbound;
 }
 
+export function createProjectPermissionsToJSON(
+  createProjectPermissions: CreateProjectPermissions,
+): string {
+  return JSON.stringify(
+    CreateProjectPermissions$outboundSchema.parse(createProjectPermissions),
+  );
+}
+
+export function createProjectPermissionsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectPermissions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectPermissions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectPermissions' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectLastRollbackTarget$inboundSchema: z.ZodType<
   CreateProjectLastRollbackTarget,
@@ -6382,6 +7591,26 @@ export namespace CreateProjectLastRollbackTarget$ {
   export type Outbound = CreateProjectLastRollbackTarget$Outbound;
 }
 
+export function createProjectLastRollbackTargetToJSON(
+  createProjectLastRollbackTarget: CreateProjectLastRollbackTarget,
+): string {
+  return JSON.stringify(
+    CreateProjectLastRollbackTarget$outboundSchema.parse(
+      createProjectLastRollbackTarget,
+    ),
+  );
+}
+
+export function createProjectLastRollbackTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLastRollbackTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLastRollbackTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLastRollbackTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectJobStatus$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectJobStatus
@@ -6481,6 +7710,26 @@ export namespace CreateProjectLastAliasRequest$ {
   export type Outbound = CreateProjectLastAliasRequest$Outbound;
 }
 
+export function createProjectLastAliasRequestToJSON(
+  createProjectLastAliasRequest: CreateProjectLastAliasRequest,
+): string {
+  return JSON.stringify(
+    CreateProjectLastAliasRequest$outboundSchema.parse(
+      createProjectLastAliasRequest,
+    ),
+  );
+}
+
+export function createProjectLastAliasRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectLastAliasRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectLastAliasRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectLastAliasRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectScope$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectScope
@@ -6544,6 +7793,26 @@ export namespace CreateProjectProtectionBypass$ {
   export type Outbound = CreateProjectProtectionBypass$Outbound;
 }
 
+export function createProjectProtectionBypassToJSON(
+  createProjectProtectionBypass: CreateProjectProtectionBypass,
+): string {
+  return JSON.stringify(
+    CreateProjectProtectionBypass$outboundSchema.parse(
+      createProjectProtectionBypass,
+    ),
+  );
+}
+
+export function createProjectProtectionBypassFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProtectionBypass, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProtectionBypass$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProtectionBypass' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectTrustedIpsProjectsDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectTrustedIpsProjectsDeploymentType> = z
@@ -6603,6 +7872,24 @@ export namespace CreateProjectTrustedIps2$ {
   export type Outbound = CreateProjectTrustedIps2$Outbound;
 }
 
+export function createProjectTrustedIps2ToJSON(
+  createProjectTrustedIps2: CreateProjectTrustedIps2,
+): string {
+  return JSON.stringify(
+    CreateProjectTrustedIps2$outboundSchema.parse(createProjectTrustedIps2),
+  );
+}
+
+export function createProjectTrustedIps2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectTrustedIps2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectTrustedIps2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectTrustedIps2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectTrustedIpsDeploymentType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectTrustedIpsDeploymentType> = z.nativeEnum(
@@ -6666,6 +7953,24 @@ export namespace TrustedIpsAddresses$ {
   export type Outbound = TrustedIpsAddresses$Outbound;
 }
 
+export function trustedIpsAddressesToJSON(
+  trustedIpsAddresses: TrustedIpsAddresses,
+): string {
+  return JSON.stringify(
+    TrustedIpsAddresses$outboundSchema.parse(trustedIpsAddresses),
+  );
+}
+
+export function trustedIpsAddressesFromJSON(
+  jsonString: string,
+): SafeParseResult<TrustedIpsAddresses, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrustedIpsAddresses$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrustedIpsAddresses' from JSON`,
+  );
+}
+
 /** @internal */
 export const TrustedIpsProtectionMode$inboundSchema: z.ZodNativeEnum<
   typeof TrustedIpsProtectionMode
@@ -6729,6 +8034,24 @@ export namespace CreateProjectTrustedIps1$ {
   export type Outbound = CreateProjectTrustedIps1$Outbound;
 }
 
+export function createProjectTrustedIps1ToJSON(
+  createProjectTrustedIps1: CreateProjectTrustedIps1,
+): string {
+  return JSON.stringify(
+    CreateProjectTrustedIps1$outboundSchema.parse(createProjectTrustedIps1),
+  );
+}
+
+export function createProjectTrustedIps1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectTrustedIps1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectTrustedIps1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectTrustedIps1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectTrustedIps$inboundSchema: z.ZodType<
   CreateProjectTrustedIps,
@@ -6767,6 +8090,24 @@ export namespace CreateProjectTrustedIps$ {
   export type Outbound = CreateProjectTrustedIps$Outbound;
 }
 
+export function createProjectTrustedIpsToJSON(
+  createProjectTrustedIps: CreateProjectTrustedIps,
+): string {
+  return JSON.stringify(
+    CreateProjectTrustedIps$outboundSchema.parse(createProjectTrustedIps),
+  );
+}
+
+export function createProjectTrustedIpsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectTrustedIps, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectTrustedIps$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectTrustedIps' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectGitComments$inboundSchema: z.ZodType<
   CreateProjectGitComments,
@@ -6806,6 +8147,24 @@ export namespace CreateProjectGitComments$ {
   export type Outbound = CreateProjectGitComments$Outbound;
 }
 
+export function createProjectGitCommentsToJSON(
+  createProjectGitComments: CreateProjectGitComments,
+): string {
+  return JSON.stringify(
+    CreateProjectGitComments$outboundSchema.parse(createProjectGitComments),
+  );
+}
+
+export function createProjectGitCommentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectGitComments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectGitComments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectGitComments' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectWebAnalytics$inboundSchema: z.ZodType<
   CreateProjectWebAnalytics,
@@ -6854,6 +8213,24 @@ export namespace CreateProjectWebAnalytics$ {
   export type Outbound = CreateProjectWebAnalytics$Outbound;
 }
 
+export function createProjectWebAnalyticsToJSON(
+  createProjectWebAnalytics: CreateProjectWebAnalytics,
+): string {
+  return JSON.stringify(
+    CreateProjectWebAnalytics$outboundSchema.parse(createProjectWebAnalytics),
+  );
+}
+
+export function createProjectWebAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectWebAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectWebAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectWebAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectSrc2$inboundSchema: z.ZodType<
   CreateProjectSrc2,
@@ -6920,6 +8297,24 @@ export namespace CreateProjectSrc2$ {
   export type Outbound = CreateProjectSrc2$Outbound;
 }
 
+export function createProjectSrc2ToJSON(
+  createProjectSrc2: CreateProjectSrc2,
+): string {
+  return JSON.stringify(
+    CreateProjectSrc2$outboundSchema.parse(createProjectSrc2),
+  );
+}
+
+export function createProjectSrc2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectSrc2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectSrc2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectSrc2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectSrc$inboundSchema: z.ZodType<
   CreateProjectSrc,
@@ -6950,6 +8345,24 @@ export namespace CreateProjectSrc$ {
   export type Outbound = CreateProjectSrc$Outbound;
 }
 
+export function createProjectSrcToJSON(
+  createProjectSrc: CreateProjectSrc,
+): string {
+  return JSON.stringify(
+    CreateProjectSrc$outboundSchema.parse(createProjectSrc),
+  );
+}
+
+export function createProjectSrcFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectSrc, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectSrc$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectSrc' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponse200ApplicationJSONResponseBodySecurityType$inboundSchema:
   z.ZodNativeEnum<
@@ -7044,6 +8457,24 @@ export namespace CreateProjectValue2$ {
   export type Outbound = CreateProjectValue2$Outbound;
 }
 
+export function createProjectValue2ToJSON(
+  createProjectValue2: CreateProjectValue2,
+): string {
+  return JSON.stringify(
+    CreateProjectValue2$outboundSchema.parse(createProjectValue2),
+  );
+}
+
+export function createProjectValue2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectValue2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectValue2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectValue2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectValue$inboundSchema: z.ZodType<
   CreateProjectValue,
@@ -7074,6 +8505,24 @@ export namespace CreateProjectValue$ {
   export type Outbound = CreateProjectValue$Outbound;
 }
 
+export function createProjectValueToJSON(
+  createProjectValue: CreateProjectValue,
+): string {
+  return JSON.stringify(
+    CreateProjectValue$outboundSchema.parse(createProjectValue),
+  );
+}
+
+export function createProjectValueFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectHas$inboundSchema: z.ZodType<
   CreateProjectHas,
@@ -7120,6 +8569,24 @@ export namespace CreateProjectHas$ {
   export type Outbound = CreateProjectHas$Outbound;
 }
 
+export function createProjectHasToJSON(
+  createProjectHas: CreateProjectHas,
+): string {
+  return JSON.stringify(
+    CreateProjectHas$outboundSchema.parse(createProjectHas),
+  );
+}
+
+export function createProjectHasFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectHas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectHas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectHas' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$inboundSchema:
   z.ZodNativeEnum<
@@ -7214,6 +8681,26 @@ export namespace CreateProjectValueProjects2$ {
   export type Outbound = CreateProjectValueProjects2$Outbound;
 }
 
+export function createProjectValueProjects2ToJSON(
+  createProjectValueProjects2: CreateProjectValueProjects2,
+): string {
+  return JSON.stringify(
+    CreateProjectValueProjects2$outboundSchema.parse(
+      createProjectValueProjects2,
+    ),
+  );
+}
+
+export function createProjectValueProjects2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectValueProjects2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectValueProjects2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectValueProjects2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectProjectsValue$inboundSchema: z.ZodType<
   CreateProjectProjectsValue,
@@ -7252,6 +8739,24 @@ export namespace CreateProjectProjectsValue$ {
   export type Outbound = CreateProjectProjectsValue$Outbound;
 }
 
+export function createProjectProjectsValueToJSON(
+  createProjectProjectsValue: CreateProjectProjectsValue,
+): string {
+  return JSON.stringify(
+    CreateProjectProjectsValue$outboundSchema.parse(createProjectProjectsValue),
+  );
+}
+
+export function createProjectProjectsValueFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectProjectsValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectProjectsValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectProjectsValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectMissing$inboundSchema: z.ZodType<
   CreateProjectMissing,
@@ -7302,6 +8807,24 @@ export namespace CreateProjectMissing$ {
   export type Outbound = CreateProjectMissing$Outbound;
 }
 
+export function createProjectMissingToJSON(
+  createProjectMissing: CreateProjectMissing,
+): string {
+  return JSON.stringify(
+    CreateProjectMissing$outboundSchema.parse(createProjectMissing),
+  );
+}
+
+export function createProjectMissingFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectMissing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectMissing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectMissing' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectHandle$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectHandle
@@ -7410,6 +8933,24 @@ export namespace CreateProjectErl$ {
   export type Outbound = CreateProjectErl$Outbound;
 }
 
+export function createProjectErlToJSON(
+  createProjectErl: CreateProjectErl,
+): string {
+  return JSON.stringify(
+    CreateProjectErl$outboundSchema.parse(createProjectErl),
+  );
+}
+
+export function createProjectErlFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectErl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectErl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectErl' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectMitigate$inboundSchema: z.ZodType<
   CreateProjectMitigate,
@@ -7463,6 +9004,24 @@ export namespace CreateProjectMitigate$ {
   export type Outbound = CreateProjectMitigate$Outbound;
 }
 
+export function createProjectMitigateToJSON(
+  createProjectMitigate: CreateProjectMitigate,
+): string {
+  return JSON.stringify(
+    CreateProjectMitigate$outboundSchema.parse(createProjectMitigate),
+  );
+}
+
+export function createProjectMitigateFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectMitigate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectMitigate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectMitigate' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectFirewallRoutes$inboundSchema: z.ZodType<
   CreateProjectFirewallRoutes,
@@ -7520,6 +9079,26 @@ export namespace CreateProjectFirewallRoutes$ {
   export type Outbound = CreateProjectFirewallRoutes$Outbound;
 }
 
+export function createProjectFirewallRoutesToJSON(
+  createProjectFirewallRoutes: CreateProjectFirewallRoutes,
+): string {
+  return JSON.stringify(
+    CreateProjectFirewallRoutes$outboundSchema.parse(
+      createProjectFirewallRoutes,
+    ),
+  );
+}
+
+export function createProjectFirewallRoutesFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFirewallRoutes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectFirewallRoutes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFirewallRoutes' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectSecurity$inboundSchema: z.ZodType<
   CreateProjectSecurity,
@@ -7538,6 +9117,7 @@ export const CreateProjectSecurity$inboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /** @internal */
@@ -7552,6 +9132,7 @@ export type CreateProjectSecurity$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7572,6 +9153,7 @@ export const CreateProjectSecurity$outboundSchema: z.ZodType<
   firewallSeawallEnabled: z.boolean().optional(),
   ja3Enabled: z.boolean().optional(),
   ja4Enabled: z.boolean().optional(),
+  firewallBypassIps: z.array(z.string()).optional(),
 });
 
 /**
@@ -7587,6 +9169,24 @@ export namespace CreateProjectSecurity$ {
   export type Outbound = CreateProjectSecurity$Outbound;
 }
 
+export function createProjectSecurityToJSON(
+  createProjectSecurity: CreateProjectSecurity,
+): string {
+  return JSON.stringify(
+    CreateProjectSecurity$outboundSchema.parse(createProjectSecurity),
+  );
+}
+
+export function createProjectSecurityFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectSecurity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectSecurity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectSecurity' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectIssuerMode$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectIssuerMode
@@ -7647,6 +9247,26 @@ export namespace CreateProjectOidcTokenConfig$ {
   export type Outbound = CreateProjectOidcTokenConfig$Outbound;
 }
 
+export function createProjectOidcTokenConfigToJSON(
+  createProjectOidcTokenConfig: CreateProjectOidcTokenConfig,
+): string {
+  return JSON.stringify(
+    CreateProjectOidcTokenConfig$outboundSchema.parse(
+      createProjectOidcTokenConfig,
+    ),
+  );
+}
+
+export function createProjectOidcTokenConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectOidcTokenConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectOidcTokenConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectOidcTokenConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectTier$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectTier
@@ -7714,6 +9334,8 @@ export const CreateProjectResponseBody$inboundSchema: z.ZodType<
     z.lazy(() => CreateProjectLink3$inboundSchema),
     z.lazy(() => CreateProjectLink2$inboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => CreateProjectMicrofrontends$inboundSchema)
+    .optional(),
   name: z.string(),
   nodeVersion: CreateProjectNodeVersion$inboundSchema,
   optionsAllowlist: z.nullable(
@@ -7818,6 +9440,7 @@ export type CreateProjectResponseBody$Outbound = {
     | CreateProjectLink3$Outbound
     | CreateProjectLink2$Outbound
     | undefined;
+  microfrontends?: CreateProjectMicrofrontends$Outbound | undefined;
   name: string;
   nodeVersion: string;
   optionsAllowlist?: CreateProjectOptionsAllowlist$Outbound | null | undefined;
@@ -7919,6 +9542,8 @@ export const CreateProjectResponseBody$outboundSchema: z.ZodType<
     z.lazy(() => CreateProjectLink3$outboundSchema),
     z.lazy(() => CreateProjectLink2$outboundSchema),
   ]).optional(),
+  microfrontends: z.lazy(() => CreateProjectMicrofrontends$outboundSchema)
+    .optional(),
   name: z.string(),
   nodeVersion: CreateProjectNodeVersion$outboundSchema,
   optionsAllowlist: z.nullable(
@@ -7995,3 +9620,21 @@ export namespace CreateProjectResponseBody$ {
   /** @deprecated use `CreateProjectResponseBody$Outbound` instead. */
   export type Outbound = CreateProjectResponseBody$Outbound;
 }
+
+export function createProjectResponseBodyToJSON(
+  createProjectResponseBody: CreateProjectResponseBody,
+): string {
+  return JSON.stringify(
+    CreateProjectResponseBody$outboundSchema.parse(createProjectResponseBody),
+  );
+}
+
+export function createProjectResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectResponseBody' from JSON`,
+  );
+}