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

package/src/models/operations/createdeployment.ts

@@ -4,13 +4,16 @@
 
 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 {
   FlagJSONValue,
   FlagJSONValue$inboundSchema,
   FlagJSONValue$Outbound,
   FlagJSONValue$outboundSchema,
 } from "../components/flagjsonvalue.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Allows to skip framework detection so the API would not fail to ask for confirmation
@@ -631,6 +634,9 @@ export type CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONRespon
     typeof CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody6Type
   >;
 
+/**
+ * Allows custom git sources (local folder mounted to the container) in test mode
+ */
 export type CreateDeploymentGitSource6 = {
   type:
     CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody6Type;
@@ -764,6 +770,7 @@ export const CreateDeploymentSource = {
   CloneRepo: "clone/repo",
   ApiTriggerGitDeploy: "api-trigger-git-deploy",
   Redeploy: "redeploy",
+  V0Web: "v0-web",
 } as const;
 export type CreateDeploymentSource = ClosedEnum<typeof CreateDeploymentSource>;
 
@@ -824,6 +831,54 @@ export type OidcTokenClaims = {
   environment: string;
 };
 
+/**
+ * A map of the other applications that are part of this group. Only defined on the default application. The field is set after deployments have been created, so can be undefined, but should be there for a successful deployment.
+ */
+export type Applications = {
+  /**
+   * This is the production alias, it will always show the most up to date of each application.
+   */
+  productionHost: string;
+  /**
+   * Use the fixed deploymentAlias and deploymentHost so that the microfrontend preview stays in sync with the deployment. These are only present for mono-repos when a single commit creates multiple deployments. If they are not present, productionHost will be used.
+   */
+  deploymentAlias?: string | undefined;
+  deploymentHost?: string | undefined;
+};
+
+export type Microfrontends2 = {
+  /**
+   * A map of the other applications that are part of this group. Only defined on the default application. The field is set after deployments have been created, so can be undefined, but should be there for a successful deployment.
+   */
+  applications?: { [k: string]: Applications } | undefined;
+  isDefaultApp: boolean;
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+  groupIds: Array<string>;
+};
+
+export type Microfrontends1 = {
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+  groupIds: Array<string>;
+};
+
+export type CreateDeploymentMicrofrontends = Microfrontends1 | Microfrontends2;
+
 export type Functions = {
   memory?: number | undefined;
   maxDuration?: number | undefined;
@@ -1150,6 +1205,7 @@ export type CreateDeploymentResponseBody = {
   oidcTokenClaims?: OidcTokenClaims | undefined;
   projectId: string;
   ownerId: string;
+  microfrontends?: Microfrontends1 | Microfrontends2 | undefined;
   monorepoManager?: string | null | undefined;
   functions?: { [k: string]: Functions } | null | undefined;
   routes: Array<Routes3 | Routes2 | Routes1> | null;
@@ -1248,6 +1304,20 @@ export namespace UploadedFile$ {
   export type Outbound = UploadedFile$Outbound;
 }
 
+export function uploadedFileToJSON(uploadedFile: UploadedFile): string {
+  return JSON.stringify(UploadedFile$outboundSchema.parse(uploadedFile));
+}
+
+export function uploadedFileFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadedFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadedFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadedFile' from JSON`,
+  );
+}
+
 /** @internal */
 export const Encoding$inboundSchema: z.ZodNativeEnum<typeof Encoding> = z
   .nativeEnum(Encoding);
@@ -1309,6 +1379,20 @@ export namespace InlinedFile$ {
   export type Outbound = InlinedFile$Outbound;
 }
 
+export function inlinedFileToJSON(inlinedFile: InlinedFile): string {
+  return JSON.stringify(InlinedFile$outboundSchema.parse(inlinedFile));
+}
+
+export function inlinedFileFromJSON(
+  jsonString: string,
+): SafeParseResult<InlinedFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InlinedFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InlinedFile' from JSON`,
+  );
+}
+
 /** @internal */
 export const Files$inboundSchema: z.ZodType<Files, z.ZodTypeDef, unknown> = z
   .union([
@@ -1342,6 +1426,20 @@ export namespace Files$ {
   export type Outbound = Files$Outbound;
 }
 
+export function filesToJSON(files: Files): string {
+  return JSON.stringify(Files$outboundSchema.parse(files));
+}
+
+export function filesFromJSON(
+  jsonString: string,
+): SafeParseResult<Files, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Files$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Files' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitMetadata$inboundSchema: z.ZodType<
   GitMetadata,
@@ -1393,6 +1491,20 @@ export namespace GitMetadata$ {
   export type Outbound = GitMetadata$Outbound;
 }
 
+export function gitMetadataToJSON(gitMetadata: GitMetadata): string {
+  return JSON.stringify(GitMetadata$outboundSchema.parse(gitMetadata));
+}
+
+export function gitMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GitMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsRequestType$inboundSchema:
   z.ZodNativeEnum<typeof CreateDeploymentGitSourceDeploymentsRequestType> = z
@@ -1458,6 +1570,20 @@ export namespace Five$ {
   export type Outbound = Five$Outbound;
 }
 
+export function fiveToJSON(five: Five): string {
+  return JSON.stringify(Five$outboundSchema.parse(five));
+}
+
+export function fiveFromJSON(
+  jsonString: string,
+): SafeParseResult<Five, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Five$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Five' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsType$inboundSchema:
   z.ZodNativeEnum<typeof CreateDeploymentGitSourceDeploymentsType> = z
@@ -1523,6 +1649,20 @@ export namespace Four$ {
   export type Outbound = Four$Outbound;
 }
 
+export function fourToJSON(four: Four): string {
+  return JSON.stringify(Four$outboundSchema.parse(four));
+}
+
+export function fourFromJSON(
+  jsonString: string,
+): SafeParseResult<Four, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Four$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Four' from JSON`,
+  );
+}
+
 /** @internal */
 export const ProjectId$inboundSchema: z.ZodType<
   ProjectId,
@@ -1553,6 +1693,20 @@ export namespace ProjectId$ {
   export type Outbound = ProjectId$Outbound;
 }
 
+export function projectIdToJSON(projectId: ProjectId): string {
+  return JSON.stringify(ProjectId$outboundSchema.parse(projectId));
+}
+
+export function projectIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectId' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceType$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentGitSourceType
@@ -1616,6 +1770,20 @@ export namespace Three$ {
   export type Outbound = Three$Outbound;
 }
 
+export function threeToJSON(three: Three): string {
+  return JSON.stringify(Three$outboundSchema.parse(three));
+}
+
+export function threeFromJSON(
+  jsonString: string,
+): SafeParseResult<Three, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Three$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Three' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitSourceType$inboundSchema: z.ZodNativeEnum<
   typeof GitSourceType
@@ -1679,6 +1847,20 @@ export namespace Two$ {
   export type Outbound = Two$Outbound;
 }
 
+export function twoToJSON(two: Two): string {
+  return JSON.stringify(Two$outboundSchema.parse(two));
+}
+
+export function twoFromJSON(
+  jsonString: string,
+): SafeParseResult<Two, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two' from JSON`,
+  );
+}
+
 /** @internal */
 export const RepoId$inboundSchema: z.ZodType<RepoId, z.ZodTypeDef, unknown> = z
   .union([z.number(), z.string()]);
@@ -1706,6 +1888,20 @@ export namespace RepoId$ {
   export type Outbound = RepoId$Outbound;
 }
 
+export function repoIdToJSON(repoId: RepoId): string {
+  return JSON.stringify(RepoId$outboundSchema.parse(repoId));
+}
+
+export function repoIdFromJSON(
+  jsonString: string,
+): SafeParseResult<RepoId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RepoId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RepoId' from JSON`,
+  );
+}
+
 /** @internal */
 export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
   Type,
@@ -1765,6 +1961,20 @@ export namespace One$ {
   export type Outbound = One$Outbound;
 }
 
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
+}
+
+export function oneFromJSON(
+  jsonString: string,
+): SafeParseResult<One, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitSource$inboundSchema: z.ZodType<
   GitSource,
@@ -1812,6 +2022,20 @@ export namespace GitSource$ {
   export type Outbound = GitSource$Outbound;
 }
 
+export function gitSourceToJSON(gitSource: GitSource): string {
+  return JSON.stringify(GitSource$outboundSchema.parse(gitSource));
+}
+
+export function gitSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource' from JSON`,
+  );
+}
+
 /** @internal */
 export const Framework$inboundSchema: z.ZodNativeEnum<typeof Framework> = z
   .nativeEnum(Framework);
@@ -1916,6 +2140,22 @@ export namespace ProjectSettings$ {
   export type Outbound = ProjectSettings$Outbound;
 }
 
+export function projectSettingsToJSON(
+  projectSettings: ProjectSettings,
+): string {
+  return JSON.stringify(ProjectSettings$outboundSchema.parse(projectSettings));
+}
+
+export function projectSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<ProjectSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProjectSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProjectSettings' from JSON`,
+  );
+}
+
 /** @internal */
 export const Target$inboundSchema: z.ZodNativeEnum<typeof Target> = z
   .nativeEnum(Target);
@@ -2029,6 +2269,26 @@ export namespace CreateDeploymentRequestBody$ {
   export type Outbound = CreateDeploymentRequestBody$Outbound;
 }
 
+export function createDeploymentRequestBodyToJSON(
+  createDeploymentRequestBody: CreateDeploymentRequestBody,
+): string {
+  return JSON.stringify(
+    CreateDeploymentRequestBody$outboundSchema.parse(
+      createDeploymentRequestBody,
+    ),
+  );
+}
+
+export function createDeploymentRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentRequest$inboundSchema: z.ZodType<
   CreateDeploymentRequest,
@@ -2089,6 +2349,24 @@ export namespace CreateDeploymentRequest$ {
   export type Outbound = CreateDeploymentRequest$Outbound;
 }
 
+export function createDeploymentRequestToJSON(
+  createDeploymentRequest: CreateDeploymentRequest,
+): string {
+  return JSON.stringify(
+    CreateDeploymentRequest$outboundSchema.parse(createDeploymentRequest),
+  );
+}
+
+export function createDeploymentRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const AliasAssignedAt$inboundSchema: z.ZodType<
   AliasAssignedAt,
@@ -2119,6 +2397,22 @@ export namespace AliasAssignedAt$ {
   export type Outbound = AliasAssignedAt$Outbound;
 }
 
+export function aliasAssignedAtToJSON(
+  aliasAssignedAt: AliasAssignedAt,
+): string {
+  return JSON.stringify(AliasAssignedAt$outboundSchema.parse(aliasAssignedAt));
+}
+
+export function aliasAssignedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<AliasAssignedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AliasAssignedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AliasAssignedAt' from JSON`,
+  );
+}
+
 /** @internal */
 export const Build$inboundSchema: z.ZodType<Build, z.ZodTypeDef, unknown> = z
   .object({
@@ -2152,6 +2446,20 @@ export namespace Build$ {
   export type Outbound = Build$Outbound;
 }
 
+export function buildToJSON(build: Build): string {
+  return JSON.stringify(Build$outboundSchema.parse(build));
+}
+
+export function buildFromJSON(
+  jsonString: string,
+): SafeParseResult<Build, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Build$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Build' from JSON`,
+  );
+}
+
 /** @internal */
 export const Builds$inboundSchema: z.ZodType<Builds, z.ZodTypeDef, unknown> = z
   .object({});
@@ -2179,6 +2487,20 @@ export namespace Builds$ {
   export type Outbound = Builds$Outbound;
 }
 
+export function buildsToJSON(builds: Builds): string {
+  return JSON.stringify(Builds$outboundSchema.parse(builds));
+}
+
+export function buildsFromJSON(
+  jsonString: string,
+): SafeParseResult<Builds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Builds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Builds' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentFramework$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentFramework
@@ -2251,6 +2573,26 @@ export namespace CreateDeploymentSpeedInsights$ {
   export type Outbound = CreateDeploymentSpeedInsights$Outbound;
 }
 
+export function createDeploymentSpeedInsightsToJSON(
+  createDeploymentSpeedInsights: CreateDeploymentSpeedInsights,
+): string {
+  return JSON.stringify(
+    CreateDeploymentSpeedInsights$outboundSchema.parse(
+      createDeploymentSpeedInsights,
+    ),
+  );
+}
+
+export function createDeploymentSpeedInsightsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentSpeedInsights, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentSpeedInsights$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentSpeedInsights' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentWebAnalytics$inboundSchema: z.ZodType<
   CreateDeploymentWebAnalytics,
@@ -2299,6 +2641,26 @@ export namespace CreateDeploymentWebAnalytics$ {
   export type Outbound = CreateDeploymentWebAnalytics$Outbound;
 }
 
+export function createDeploymentWebAnalyticsToJSON(
+  createDeploymentWebAnalytics: CreateDeploymentWebAnalytics,
+): string {
+  return JSON.stringify(
+    CreateDeploymentWebAnalytics$outboundSchema.parse(
+      createDeploymentWebAnalytics,
+    ),
+  );
+}
+
+export function createDeploymentWebAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentWebAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentWebAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentWebAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentProjectSettings$inboundSchema: z.ZodType<
   CreateDeploymentProjectSettings,
@@ -2360,6 +2722,26 @@ export namespace CreateDeploymentProjectSettings$ {
   export type Outbound = CreateDeploymentProjectSettings$Outbound;
 }
 
+export function createDeploymentProjectSettingsToJSON(
+  createDeploymentProjectSettings: CreateDeploymentProjectSettings,
+): string {
+  return JSON.stringify(
+    CreateDeploymentProjectSettings$outboundSchema.parse(
+      createDeploymentProjectSettings,
+    ),
+  );
+}
+
+export function createDeploymentProjectSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentProjectSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentProjectSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentProjectSettings' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentDeploymentsStatus$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentDeploymentsStatus
@@ -2430,6 +2812,20 @@ export namespace Integrations$ {
   export type Outbound = Integrations$Outbound;
 }
 
+export function integrationsToJSON(integrations: Integrations): string {
+  return JSON.stringify(Integrations$outboundSchema.parse(integrations));
+}
+
+export function integrationsFromJSON(
+  jsonString: string,
+): SafeParseResult<Integrations, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Integrations$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Integrations' from JSON`,
+  );
+}
+
 /** @internal */
 export const Creator$inboundSchema: z.ZodType<Creator, z.ZodTypeDef, unknown> =
   z.object({
@@ -2469,6 +2865,20 @@ export namespace Creator$ {
   export type Outbound = Creator$Outbound;
 }
 
+export function creatorToJSON(creator: Creator): string {
+  return JSON.stringify(Creator$outboundSchema.parse(creator));
+}
+
+export function creatorFromJSON(
+  jsonString: string,
+): SafeParseResult<Creator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Creator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Creator' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentReadyState$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentReadyState
@@ -2529,6 +2939,24 @@ export namespace CreateDeploymentOutput$ {
   export type Outbound = CreateDeploymentOutput$Outbound;
 }
 
+export function createDeploymentOutputToJSON(
+  createDeploymentOutput: CreateDeploymentOutput,
+): string {
+  return JSON.stringify(
+    CreateDeploymentOutput$outboundSchema.parse(createDeploymentOutput),
+  );
+}
+
+export function createDeploymentOutputFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentOutput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentOutput' from JSON`,
+  );
+}
+
 /** @internal */
 export const Lambdas$inboundSchema: z.ZodType<Lambdas, z.ZodTypeDef, unknown> =
   z.object({
@@ -2577,6 +3005,20 @@ export namespace Lambdas$ {
   export type Outbound = Lambdas$Outbound;
 }
 
+export function lambdasToJSON(lambdas: Lambdas): string {
+  return JSON.stringify(Lambdas$outboundSchema.parse(lambdas));
+}
+
+export function lambdasFromJSON(
+  jsonString: string,
+): SafeParseResult<Lambdas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Lambdas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Lambdas' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentStatus$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentStatus
@@ -2637,6 +3079,20 @@ export namespace Team$ {
   export type Outbound = Team$Outbound;
 }
 
+export function teamToJSON(team: Team): string {
+  return JSON.stringify(Team$outboundSchema.parse(team));
+}
+
+export function teamFromJSON(
+  jsonString: string,
+): SafeParseResult<Team, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Team$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Team' from JSON`,
+  );
+}
+
 /** @internal */
 export const CustomEnvironment2$inboundSchema: z.ZodType<
   CustomEnvironment2,
@@ -2673,6 +3129,24 @@ export namespace CustomEnvironment2$ {
   export type Outbound = CustomEnvironment2$Outbound;
 }
 
+export function customEnvironment2ToJSON(
+  customEnvironment2: CustomEnvironment2,
+): string {
+  return JSON.stringify(
+    CustomEnvironment2$outboundSchema.parse(customEnvironment2),
+  );
+}
+
+export function customEnvironment2FromJSON(
+  jsonString: string,
+): SafeParseResult<CustomEnvironment2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomEnvironment2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomEnvironment2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CustomEnvironment1$inboundSchema: z.ZodType<
   CustomEnvironment1,
@@ -2703,6 +3177,24 @@ export namespace CustomEnvironment1$ {
   export type Outbound = CustomEnvironment1$Outbound;
 }
 
+export function customEnvironment1ToJSON(
+  customEnvironment1: CustomEnvironment1,
+): string {
+  return JSON.stringify(
+    CustomEnvironment1$outboundSchema.parse(customEnvironment1),
+  );
+}
+
+export function customEnvironment1FromJSON(
+  jsonString: string,
+): SafeParseResult<CustomEnvironment1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomEnvironment1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomEnvironment1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CustomEnvironment$inboundSchema: z.ZodType<
   CustomEnvironment,
@@ -2741,6 +3233,24 @@ export namespace CustomEnvironment$ {
   export type Outbound = CustomEnvironment$Outbound;
 }
 
+export function customEnvironmentToJSON(
+  customEnvironment: CustomEnvironment,
+): string {
+  return JSON.stringify(
+    CustomEnvironment$outboundSchema.parse(customEnvironment),
+  );
+}
+
+export function customEnvironmentFromJSON(
+  jsonString: string,
+): SafeParseResult<CustomEnvironment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CustomEnvironment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CustomEnvironment' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentType$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentType
@@ -2846,6 +3356,24 @@ export namespace CreateDeploymentGitSource9$ {
   export type Outbound = CreateDeploymentGitSource9$Outbound;
 }
 
+export function createDeploymentGitSource9ToJSON(
+  createDeploymentGitSource9: CreateDeploymentGitSource9,
+): string {
+  return JSON.stringify(
+    CreateDeploymentGitSource9$outboundSchema.parse(createDeploymentGitSource9),
+  );
+}
+
+export function createDeploymentGitSource9FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentGitSource9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentGitSource9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentGitSource9' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody8Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2921,6 +3449,24 @@ export namespace CreateDeploymentGitSource8$ {
   export type Outbound = CreateDeploymentGitSource8$Outbound;
 }
 
+export function createDeploymentGitSource8ToJSON(
+  createDeploymentGitSource8: CreateDeploymentGitSource8,
+): string {
+  return JSON.stringify(
+    CreateDeploymentGitSource8$outboundSchema.parse(createDeploymentGitSource8),
+  );
+}
+
+export function createDeploymentGitSource8FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentGitSource8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentGitSource8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentGitSource8' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody7Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3002,6 +3548,24 @@ export namespace CreateDeploymentGitSource7$ {
   export type Outbound = CreateDeploymentGitSource7$Outbound;
 }
 
+export function createDeploymentGitSource7ToJSON(
+  createDeploymentGitSource7: CreateDeploymentGitSource7,
+): string {
+  return JSON.stringify(
+    CreateDeploymentGitSource7$outboundSchema.parse(createDeploymentGitSource7),
+  );
+}
+
+export function createDeploymentGitSource7FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentGitSource7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentGitSource7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentGitSource7' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody6Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3077,6 +3641,24 @@ export namespace CreateDeploymentGitSource6$ {
   export type Outbound = CreateDeploymentGitSource6$Outbound;
 }
 
+export function createDeploymentGitSource6ToJSON(
+  createDeploymentGitSource6: CreateDeploymentGitSource6,
+): string {
+  return JSON.stringify(
+    CreateDeploymentGitSource6$outboundSchema.parse(createDeploymentGitSource6),
+  );
+}
+
+export function createDeploymentGitSource6FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentGitSource6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentGitSource6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentGitSource6' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBody5Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3158,6 +3740,20 @@ export namespace GitSource5$ {
   export type Outbound = GitSource5$Outbound;
 }
 
+export function gitSource5ToJSON(gitSource5: GitSource5): string {
+  return JSON.stringify(GitSource5$outboundSchema.parse(gitSource5));
+}
+
+export function gitSource5FromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource5' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -3239,6 +3835,20 @@ export namespace GitSource4$ {
   export type Outbound = GitSource4$Outbound;
 }
 
+export function gitSource4ToJSON(gitSource4: GitSource4): string {
+  return JSON.stringify(GitSource4$outboundSchema.parse(gitSource4));
+}
+
+export function gitSource4FromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource4' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -3297,6 +3907,24 @@ export namespace GitSourceProjectId$ {
   export type Outbound = GitSourceProjectId$Outbound;
 }
 
+export function gitSourceProjectIdToJSON(
+  gitSourceProjectId: GitSourceProjectId,
+): string {
+  return JSON.stringify(
+    GitSourceProjectId$outboundSchema.parse(gitSourceProjectId),
+  );
+}
+
+export function gitSourceProjectIdFromJSON(
+  jsonString: string,
+): SafeParseResult<GitSourceProjectId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSourceProjectId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSourceProjectId' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitSource3$inboundSchema: z.ZodType<
   GitSource3,
@@ -3347,6 +3975,20 @@ export namespace GitSource3$ {
   export type Outbound = GitSource3$Outbound;
 }
 
+export function gitSource3ToJSON(gitSource3: GitSource3): string {
+  return JSON.stringify(GitSource3$outboundSchema.parse(gitSource3));
+}
+
+export function gitSource3FromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof CreateDeploymentGitSourceDeploymentsResponse200Type> =
@@ -3421,6 +4063,20 @@ export namespace GitSource2$ {
   export type Outbound = GitSource2$Outbound;
 }
 
+export function gitSource2ToJSON(gitSource2: GitSource2): string {
+  return JSON.stringify(GitSource2$outboundSchema.parse(gitSource2));
+}
+
+export function gitSource2FromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSourceDeploymentsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof CreateDeploymentGitSourceDeploymentsResponseType> = z
@@ -3474,6 +4130,22 @@ export namespace GitSourceRepoId$ {
   export type Outbound = GitSourceRepoId$Outbound;
 }
 
+export function gitSourceRepoIdToJSON(
+  gitSourceRepoId: GitSourceRepoId,
+): string {
+  return JSON.stringify(GitSourceRepoId$outboundSchema.parse(gitSourceRepoId));
+}
+
+export function gitSourceRepoIdFromJSON(
+  jsonString: string,
+): SafeParseResult<GitSourceRepoId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSourceRepoId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSourceRepoId' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitSource1$inboundSchema: z.ZodType<
   GitSource1,
@@ -3522,6 +4194,20 @@ export namespace GitSource1$ {
   export type Outbound = GitSource1$Outbound;
 }
 
+export function gitSource1ToJSON(gitSource1: GitSource1): string {
+  return JSON.stringify(GitSource1$outboundSchema.parse(gitSource1));
+}
+
+export function gitSource1FromJSON(
+  jsonString: string,
+): SafeParseResult<GitSource1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitSource1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitSource1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitSource$inboundSchema: z.ZodType<
   CreateDeploymentGitSource,
@@ -3581,6 +4267,24 @@ export namespace CreateDeploymentGitSource$ {
   export type Outbound = CreateDeploymentGitSource$Outbound;
 }
 
+export function createDeploymentGitSourceToJSON(
+  createDeploymentGitSource: CreateDeploymentGitSource,
+): string {
+  return JSON.stringify(
+    CreateDeploymentGitSource$outboundSchema.parse(createDeploymentGitSource),
+  );
+}
+
+export function createDeploymentGitSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentGitSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentGitSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentGitSource' from JSON`,
+  );
+}
+
 /** @internal */
 export const Project$inboundSchema: z.ZodType<Project, z.ZodTypeDef, unknown> =
   z.object({
@@ -3620,6 +4324,20 @@ export namespace Project$ {
   export type Outbound = Project$Outbound;
 }
 
+export function projectToJSON(project: Project): string {
+  return JSON.stringify(Project$outboundSchema.parse(project));
+}
+
+export function projectFromJSON(
+  jsonString: string,
+): SafeParseResult<Project, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Project$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Project' from JSON`,
+  );
+}
+
 /** @internal */
 export const ReadyState$inboundSchema: z.ZodNativeEnum<typeof ReadyState> = z
   .nativeEnum(ReadyState);
@@ -3726,6 +4444,20 @@ export namespace AliasWarning$ {
   export type Outbound = AliasWarning$Outbound;
 }
 
+export function aliasWarningToJSON(aliasWarning: AliasWarning): string {
+  return JSON.stringify(AliasWarning$outboundSchema.parse(aliasWarning));
+}
+
+export function aliasWarningFromJSON(
+  jsonString: string,
+): SafeParseResult<AliasWarning, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AliasWarning$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AliasWarning' from JSON`,
+  );
+}
+
 /** @internal */
 export const AliasError$inboundSchema: z.ZodType<
   AliasError,
@@ -3765,6 +4497,20 @@ export namespace AliasError$ {
   export type Outbound = AliasError$Outbound;
 }
 
+export function aliasErrorToJSON(aliasError: AliasError): string {
+  return JSON.stringify(AliasError$outboundSchema.parse(aliasError));
+}
+
+export function aliasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<AliasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AliasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AliasError' from JSON`,
+  );
+}
+
 /** @internal */
 export const ChecksState$inboundSchema: z.ZodNativeEnum<typeof ChecksState> = z
   .nativeEnum(ChecksState);
@@ -3896,6 +4642,255 @@ export namespace OidcTokenClaims$ {
   export type Outbound = OidcTokenClaims$Outbound;
 }
 
+export function oidcTokenClaimsToJSON(
+  oidcTokenClaims: OidcTokenClaims,
+): string {
+  return JSON.stringify(OidcTokenClaims$outboundSchema.parse(oidcTokenClaims));
+}
+
+export function oidcTokenClaimsFromJSON(
+  jsonString: string,
+): SafeParseResult<OidcTokenClaims, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OidcTokenClaims$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OidcTokenClaims' from JSON`,
+  );
+}
+
+/** @internal */
+export const Applications$inboundSchema: z.ZodType<
+  Applications,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  productionHost: z.string(),
+  deploymentAlias: z.string().optional(),
+  deploymentHost: z.string().optional(),
+});
+
+/** @internal */
+export type Applications$Outbound = {
+  productionHost: string;
+  deploymentAlias?: string | undefined;
+  deploymentHost?: string | undefined;
+};
+
+/** @internal */
+export const Applications$outboundSchema: z.ZodType<
+  Applications$Outbound,
+  z.ZodTypeDef,
+  Applications
+> = z.object({
+  productionHost: z.string(),
+  deploymentAlias: z.string().optional(),
+  deploymentHost: 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 Applications$ {
+  /** @deprecated use `Applications$inboundSchema` instead. */
+  export const inboundSchema = Applications$inboundSchema;
+  /** @deprecated use `Applications$outboundSchema` instead. */
+  export const outboundSchema = Applications$outboundSchema;
+  /** @deprecated use `Applications$Outbound` instead. */
+  export type Outbound = Applications$Outbound;
+}
+
+export function applicationsToJSON(applications: Applications): string {
+  return JSON.stringify(Applications$outboundSchema.parse(applications));
+}
+
+export function applicationsFromJSON(
+  jsonString: string,
+): SafeParseResult<Applications, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Applications$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Applications' from JSON`,
+  );
+}
+
+/** @internal */
+export const Microfrontends2$inboundSchema: z.ZodType<
+  Microfrontends2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  applications: z.record(z.lazy(() => Applications$inboundSchema)).optional(),
+  isDefaultApp: z.boolean(),
+  defaultRoute: z.string().optional(),
+  groupIds: z.array(z.string()),
+});
+
+/** @internal */
+export type Microfrontends2$Outbound = {
+  applications?: { [k: string]: Applications$Outbound } | undefined;
+  isDefaultApp: boolean;
+  defaultRoute?: string | undefined;
+  groupIds: Array<string>;
+};
+
+/** @internal */
+export const Microfrontends2$outboundSchema: z.ZodType<
+  Microfrontends2$Outbound,
+  z.ZodTypeDef,
+  Microfrontends2
+> = z.object({
+  applications: z.record(z.lazy(() => Applications$outboundSchema)).optional(),
+  isDefaultApp: z.boolean(),
+  defaultRoute: z.string().optional(),
+  groupIds: z.array(z.string()),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Microfrontends2$ {
+  /** @deprecated use `Microfrontends2$inboundSchema` instead. */
+  export const inboundSchema = Microfrontends2$inboundSchema;
+  /** @deprecated use `Microfrontends2$outboundSchema` instead. */
+  export const outboundSchema = Microfrontends2$outboundSchema;
+  /** @deprecated use `Microfrontends2$Outbound` instead. */
+  export type Outbound = Microfrontends2$Outbound;
+}
+
+export function microfrontends2ToJSON(
+  microfrontends2: Microfrontends2,
+): string {
+  return JSON.stringify(Microfrontends2$outboundSchema.parse(microfrontends2));
+}
+
+export function microfrontends2FromJSON(
+  jsonString: string,
+): SafeParseResult<Microfrontends2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Microfrontends2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Microfrontends2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Microfrontends1$inboundSchema: z.ZodType<
+  Microfrontends1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  isDefaultApp: z.boolean().optional(),
+  defaultRoute: z.string().optional(),
+  groupIds: z.array(z.string()),
+});
+
+/** @internal */
+export type Microfrontends1$Outbound = {
+  isDefaultApp?: boolean | undefined;
+  defaultRoute?: string | undefined;
+  groupIds: Array<string>;
+};
+
+/** @internal */
+export const Microfrontends1$outboundSchema: z.ZodType<
+  Microfrontends1$Outbound,
+  z.ZodTypeDef,
+  Microfrontends1
+> = z.object({
+  isDefaultApp: z.boolean().optional(),
+  defaultRoute: z.string().optional(),
+  groupIds: z.array(z.string()),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Microfrontends1$ {
+  /** @deprecated use `Microfrontends1$inboundSchema` instead. */
+  export const inboundSchema = Microfrontends1$inboundSchema;
+  /** @deprecated use `Microfrontends1$outboundSchema` instead. */
+  export const outboundSchema = Microfrontends1$outboundSchema;
+  /** @deprecated use `Microfrontends1$Outbound` instead. */
+  export type Outbound = Microfrontends1$Outbound;
+}
+
+export function microfrontends1ToJSON(
+  microfrontends1: Microfrontends1,
+): string {
+  return JSON.stringify(Microfrontends1$outboundSchema.parse(microfrontends1));
+}
+
+export function microfrontends1FromJSON(
+  jsonString: string,
+): SafeParseResult<Microfrontends1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Microfrontends1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Microfrontends1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateDeploymentMicrofrontends$inboundSchema: z.ZodType<
+  CreateDeploymentMicrofrontends,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => Microfrontends1$inboundSchema),
+  z.lazy(() => Microfrontends2$inboundSchema),
+]);
+
+/** @internal */
+export type CreateDeploymentMicrofrontends$Outbound =
+  | Microfrontends1$Outbound
+  | Microfrontends2$Outbound;
+
+/** @internal */
+export const CreateDeploymentMicrofrontends$outboundSchema: z.ZodType<
+  CreateDeploymentMicrofrontends$Outbound,
+  z.ZodTypeDef,
+  CreateDeploymentMicrofrontends
+> = z.union([
+  z.lazy(() => Microfrontends1$outboundSchema),
+  z.lazy(() => Microfrontends2$outboundSchema),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CreateDeploymentMicrofrontends$ {
+  /** @deprecated use `CreateDeploymentMicrofrontends$inboundSchema` instead. */
+  export const inboundSchema = CreateDeploymentMicrofrontends$inboundSchema;
+  /** @deprecated use `CreateDeploymentMicrofrontends$outboundSchema` instead. */
+  export const outboundSchema = CreateDeploymentMicrofrontends$outboundSchema;
+  /** @deprecated use `CreateDeploymentMicrofrontends$Outbound` instead. */
+  export type Outbound = CreateDeploymentMicrofrontends$Outbound;
+}
+
+export function createDeploymentMicrofrontendsToJSON(
+  createDeploymentMicrofrontends: CreateDeploymentMicrofrontends,
+): string {
+  return JSON.stringify(
+    CreateDeploymentMicrofrontends$outboundSchema.parse(
+      createDeploymentMicrofrontends,
+    ),
+  );
+}
+
+export function createDeploymentMicrofrontendsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentMicrofrontends, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentMicrofrontends$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentMicrofrontends' from JSON`,
+  );
+}
+
 /** @internal */
 export const Functions$inboundSchema: z.ZodType<
   Functions,
@@ -3944,6 +4939,20 @@ export namespace Functions$ {
   export type Outbound = Functions$Outbound;
 }
 
+export function functionsToJSON(functions: Functions): string {
+  return JSON.stringify(Functions$outboundSchema.parse(functions));
+}
+
+export function functionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Functions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Functions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Functions' from JSON`,
+  );
+}
+
 /** @internal */
 export const Routes3$inboundSchema: z.ZodType<Routes3, z.ZodTypeDef, unknown> =
   z.object({
@@ -3983,6 +4992,20 @@ export namespace Routes3$ {
   export type Outbound = Routes3$Outbound;
 }
 
+export function routes3ToJSON(routes3: Routes3): string {
+  return JSON.stringify(Routes3$outboundSchema.parse(routes3));
+}
+
+export function routes3FromJSON(
+  jsonString: string,
+): SafeParseResult<Routes3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Routes3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Routes3' from JSON`,
+  );
+}
+
 /** @internal */
 export const RoutesHandle$inboundSchema: z.ZodNativeEnum<typeof RoutesHandle> =
   z.nativeEnum(RoutesHandle);
@@ -4044,6 +5067,20 @@ export namespace Routes2$ {
   export type Outbound = Routes2$Outbound;
 }
 
+export function routes2ToJSON(routes2: Routes2): string {
+  return JSON.stringify(Routes2$outboundSchema.parse(routes2));
+}
+
+export function routes2FromJSON(
+  jsonString: string,
+): SafeParseResult<Routes2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Routes2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Routes2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentHasType$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentHasType
@@ -4101,6 +5138,20 @@ export namespace Has2$ {
   export type Outbound = Has2$Outbound;
 }
 
+export function has2ToJSON(has2: Has2): string {
+  return JSON.stringify(Has2$outboundSchema.parse(has2));
+}
+
+export function has2FromJSON(
+  jsonString: string,
+): SafeParseResult<Has2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Has2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Has2' from JSON`,
+  );
+}
+
 /** @internal */
 export const HasType$inboundSchema: z.ZodNativeEnum<typeof HasType> = z
   .nativeEnum(HasType);
@@ -4153,6 +5204,20 @@ export namespace Has1$ {
   export type Outbound = Has1$Outbound;
 }
 
+export function has1ToJSON(has1: Has1): string {
+  return JSON.stringify(Has1$outboundSchema.parse(has1));
+}
+
+export function has1FromJSON(
+  jsonString: string,
+): SafeParseResult<Has1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Has1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Has1' from JSON`,
+  );
+}
+
 /** @internal */
 export const RoutesHas$inboundSchema: z.ZodType<
   RoutesHas,
@@ -4189,6 +5254,20 @@ export namespace RoutesHas$ {
   export type Outbound = RoutesHas$Outbound;
 }
 
+export function routesHasToJSON(routesHas: RoutesHas): string {
+  return JSON.stringify(RoutesHas$outboundSchema.parse(routesHas));
+}
+
+export function routesHasFromJSON(
+  jsonString: string,
+): SafeParseResult<RoutesHas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoutesHas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoutesHas' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentMissingType$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentMissingType
@@ -4252,6 +5331,20 @@ export namespace Missing2$ {
   export type Outbound = Missing2$Outbound;
 }
 
+export function missing2ToJSON(missing2: Missing2): string {
+  return JSON.stringify(Missing2$outboundSchema.parse(missing2));
+}
+
+export function missing2FromJSON(
+  jsonString: string,
+): SafeParseResult<Missing2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Missing2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Missing2' from JSON`,
+  );
+}
+
 /** @internal */
 export const MissingType$inboundSchema: z.ZodNativeEnum<typeof MissingType> = z
   .nativeEnum(MissingType);
@@ -4310,6 +5403,20 @@ export namespace Missing1$ {
   export type Outbound = Missing1$Outbound;
 }
 
+export function missing1ToJSON(missing1: Missing1): string {
+  return JSON.stringify(Missing1$outboundSchema.parse(missing1));
+}
+
+export function missing1FromJSON(
+  jsonString: string,
+): SafeParseResult<Missing1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Missing1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Missing1' from JSON`,
+  );
+}
+
 /** @internal */
 export const RoutesMissing$inboundSchema: z.ZodType<
   RoutesMissing,
@@ -4346,6 +5453,20 @@ export namespace RoutesMissing$ {
   export type Outbound = RoutesMissing$Outbound;
 }
 
+export function routesMissingToJSON(routesMissing: RoutesMissing): string {
+  return JSON.stringify(RoutesMissing$outboundSchema.parse(routesMissing));
+}
+
+export function routesMissingFromJSON(
+  jsonString: string,
+): SafeParseResult<RoutesMissing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoutesMissing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoutesMissing' from JSON`,
+  );
+}
+
 /** @internal */
 export const Locale$inboundSchema: z.ZodType<Locale, z.ZodTypeDef, unknown> = z
   .object({
@@ -4382,6 +5503,20 @@ export namespace Locale$ {
   export type Outbound = Locale$Outbound;
 }
 
+export function localeToJSON(locale: Locale): string {
+  return JSON.stringify(Locale$outboundSchema.parse(locale));
+}
+
+export function localeFromJSON(
+  jsonString: string,
+): SafeParseResult<Locale, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Locale$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Locale' from JSON`,
+  );
+}
+
 /** @internal */
 export const Routes1$inboundSchema: z.ZodType<Routes1, z.ZodTypeDef, unknown> =
   z.object({
@@ -4480,6 +5615,20 @@ export namespace Routes1$ {
   export type Outbound = Routes1$Outbound;
 }
 
+export function routes1ToJSON(routes1: Routes1): string {
+  return JSON.stringify(Routes1$outboundSchema.parse(routes1));
+}
+
+export function routes1FromJSON(
+  jsonString: string,
+): SafeParseResult<Routes1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Routes1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Routes1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Routes$inboundSchema: z.ZodType<Routes, z.ZodTypeDef, unknown> = z
   .union([
@@ -4518,6 +5667,20 @@ export namespace Routes$ {
   export type Outbound = Routes$Outbound;
 }
 
+export function routesToJSON(routes: Routes): string {
+  return JSON.stringify(Routes$outboundSchema.parse(routes));
+}
+
+export function routesFromJSON(
+  jsonString: string,
+): SafeParseResult<Routes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Routes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Routes' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentCrons$inboundSchema: z.ZodType<
   CreateDeploymentCrons,
@@ -4557,6 +5720,24 @@ export namespace CreateDeploymentCrons$ {
   export type Outbound = CreateDeploymentCrons$Outbound;
 }
 
+export function createDeploymentCronsToJSON(
+  createDeploymentCrons: CreateDeploymentCrons,
+): string {
+  return JSON.stringify(
+    CreateDeploymentCrons$outboundSchema.parse(createDeploymentCrons),
+  );
+}
+
+export function createDeploymentCronsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentCrons, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentCrons$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentCrons' from JSON`,
+  );
+}
+
 /** @internal */
 export const Plan$inboundSchema: z.ZodNativeEnum<typeof Plan> = z.nativeEnum(
   Plan,
@@ -4685,6 +5866,20 @@ export namespace GitRepo3$ {
   export type Outbound = GitRepo3$Outbound;
 }
 
+export function gitRepo3ToJSON(gitRepo3: GitRepo3): string {
+  return JSON.stringify(GitRepo3$outboundSchema.parse(gitRepo3));
+}
+
+export function gitRepo3FromJSON(
+  jsonString: string,
+): SafeParseResult<GitRepo3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitRepo3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitRepo3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentGitRepoType$inboundSchema: z.ZodNativeEnum<
   typeof CreateDeploymentGitRepoType
@@ -4790,6 +5985,20 @@ export namespace GitRepo2$ {
   export type Outbound = GitRepo2$Outbound;
 }
 
+export function gitRepo2ToJSON(gitRepo2: GitRepo2): string {
+  return JSON.stringify(GitRepo2$outboundSchema.parse(gitRepo2));
+}
+
+export function gitRepo2FromJSON(
+  jsonString: string,
+): SafeParseResult<GitRepo2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitRepo2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitRepo2' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitRepoType$inboundSchema: z.ZodNativeEnum<typeof GitRepoType> = z
   .nativeEnum(GitRepoType);
@@ -4888,6 +6097,20 @@ export namespace GitRepo1$ {
   export type Outbound = GitRepo1$Outbound;
 }
 
+export function gitRepo1ToJSON(gitRepo1: GitRepo1): string {
+  return JSON.stringify(GitRepo1$outboundSchema.parse(gitRepo1));
+}
+
+export function gitRepo1FromJSON(
+  jsonString: string,
+): SafeParseResult<GitRepo1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitRepo1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitRepo1' from JSON`,
+  );
+}
+
 /** @internal */
 export const GitRepo$inboundSchema: z.ZodType<GitRepo, z.ZodTypeDef, unknown> =
   z.union([
@@ -4926,6 +6149,20 @@ export namespace GitRepo$ {
   export type Outbound = GitRepo$Outbound;
 }
 
+export function gitRepoToJSON(gitRepo: GitRepo): string {
+  return JSON.stringify(GitRepo$outboundSchema.parse(gitRepo));
+}
+
+export function gitRepoFromJSON(
+  jsonString: string,
+): SafeParseResult<GitRepo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitRepo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitRepo' from JSON`,
+  );
+}
+
 /** @internal */
 export const Flags2$inboundSchema: z.ZodType<Flags2, z.ZodTypeDef, unknown> = z
   .object({});
@@ -4953,6 +6190,20 @@ export namespace Flags2$ {
   export type Outbound = Flags2$Outbound;
 }
 
+export function flags2ToJSON(flags2: Flags2): string {
+  return JSON.stringify(Flags2$outboundSchema.parse(flags2));
+}
+
+export function flags2FromJSON(
+  jsonString: string,
+): SafeParseResult<Flags2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Flags2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Flags2' from JSON`,
+  );
+}
+
 /** @internal */
 export const Options$inboundSchema: z.ZodType<Options, z.ZodTypeDef, unknown> =
   z.object({
@@ -4989,6 +6240,20 @@ export namespace Options$ {
   export type Outbound = Options$Outbound;
 }
 
+export function optionsToJSON(options: Options): string {
+  return JSON.stringify(Options$outboundSchema.parse(options));
+}
+
+export function optionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Options, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Options$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Options' from JSON`,
+  );
+}
+
 /** @internal */
 export const FlagsDefinitions$inboundSchema: z.ZodType<
   FlagsDefinitions,
@@ -5031,6 +6296,24 @@ export namespace FlagsDefinitions$ {
   export type Outbound = FlagsDefinitions$Outbound;
 }
 
+export function flagsDefinitionsToJSON(
+  flagsDefinitions: FlagsDefinitions,
+): string {
+  return JSON.stringify(
+    FlagsDefinitions$outboundSchema.parse(flagsDefinitions),
+  );
+}
+
+export function flagsDefinitionsFromJSON(
+  jsonString: string,
+): SafeParseResult<FlagsDefinitions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FlagsDefinitions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FlagsDefinitions' from JSON`,
+  );
+}
+
 /** @internal */
 export const Flags1$inboundSchema: z.ZodType<Flags1, z.ZodTypeDef, unknown> = z
   .object({
@@ -5064,6 +6347,20 @@ export namespace Flags1$ {
   export type Outbound = Flags1$Outbound;
 }
 
+export function flags1ToJSON(flags1: Flags1): string {
+  return JSON.stringify(Flags1$outboundSchema.parse(flags1));
+}
+
+export function flags1FromJSON(
+  jsonString: string,
+): SafeParseResult<Flags1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Flags1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Flags1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Flags$inboundSchema: z.ZodType<Flags, z.ZodTypeDef, unknown> = z
   .union([
@@ -5097,6 +6394,20 @@ export namespace Flags$ {
   export type Outbound = Flags$Outbound;
 }
 
+export function flagsToJSON(flags: Flags): string {
+  return JSON.stringify(Flags$outboundSchema.parse(flags));
+}
+
+export function flagsFromJSON(
+  jsonString: string,
+): SafeParseResult<Flags, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Flags$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Flags' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateDeploymentResponseBody$inboundSchema: z.ZodType<
   CreateDeploymentResponseBody,
@@ -5180,6 +6491,10 @@ export const CreateDeploymentResponseBody$inboundSchema: z.ZodType<
   oidcTokenClaims: z.lazy(() => OidcTokenClaims$inboundSchema).optional(),
   projectId: z.string(),
   ownerId: z.string(),
+  microfrontends: z.union([
+    z.lazy(() => Microfrontends1$inboundSchema),
+    z.lazy(() => Microfrontends2$inboundSchema),
+  ]).optional(),
   monorepoManager: z.nullable(z.string()).optional(),
   functions: z.nullable(z.record(z.lazy(() => Functions$inboundSchema)))
     .optional(),
@@ -5290,6 +6605,10 @@ export type CreateDeploymentResponseBody$Outbound = {
   oidcTokenClaims?: OidcTokenClaims$Outbound | undefined;
   projectId: string;
   ownerId: string;
+  microfrontends?:
+    | Microfrontends1$Outbound
+    | Microfrontends2$Outbound
+    | undefined;
   monorepoManager?: string | null | undefined;
   functions?: { [k: string]: Functions$Outbound } | null | undefined;
   routes: Array<Routes3$Outbound | Routes2$Outbound | Routes1$Outbound> | null;
@@ -5392,6 +6711,10 @@ export const CreateDeploymentResponseBody$outboundSchema: z.ZodType<
   oidcTokenClaims: z.lazy(() => OidcTokenClaims$outboundSchema).optional(),
   projectId: z.string(),
   ownerId: z.string(),
+  microfrontends: z.union([
+    z.lazy(() => Microfrontends1$outboundSchema),
+    z.lazy(() => Microfrontends2$outboundSchema),
+  ]).optional(),
   monorepoManager: z.nullable(z.string()).optional(),
   functions: z.nullable(z.record(z.lazy(() => Functions$outboundSchema)))
     .optional(),
@@ -5435,3 +6758,23 @@ export namespace CreateDeploymentResponseBody$ {
   /** @deprecated use `CreateDeploymentResponseBody$Outbound` instead. */
   export type Outbound = CreateDeploymentResponseBody$Outbound;
 }
+
+export function createDeploymentResponseBodyToJSON(
+  createDeploymentResponseBody: CreateDeploymentResponseBody,
+): string {
+  return JSON.stringify(
+    CreateDeploymentResponseBody$outboundSchema.parse(
+      createDeploymentResponseBody,
+    ),
+  );
+}
+
+export function createDeploymentResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateDeploymentResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateDeploymentResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateDeploymentResponseBody' from JSON`,
+  );
+}