@vercel/sdk 14.0.0-canary.6 → 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",
@@ -332,10 +335,10 @@ export type CreateProjectProjectsTarget = Array<string> | CreateProjectTarget2;
 
 export const CreateProjectProjectsResponseType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type CreateProjectProjectsResponseType = ClosedEnum<
   typeof CreateProjectProjectsResponseType
@@ -943,29 +946,15 @@ export type CreateProjectLink =
   | CreateProjectLink3
   | CreateProjectLink2;
 
-/**
- * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
- */
-export type CreateProjectGroup = {
-  /**
-   * A unique identifier for the group of microfrontends. All related microfrontend projects will share this group ID. Example: mfe_12HKQaOmR5t5Uy6vdcQsNIiZgHGB
-   */
-  id: string;
-  /**
-   * A human readable name for the microfrontends group. This will be used to display the microfrontends group in the UI.
-   */
-  slug: string;
-};
-
 export type CreateProjectMicrofrontends = {
   /**
    * Timestamp when the microfrontends settings were last updated.
    */
   updatedAt: number;
   /**
-   * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
+   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
    */
-  group: CreateProjectGroup;
+  groupIds: Array<string>;
   /**
    * Whether microfrontends are enabled for this project.
    */
@@ -1286,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;
@@ -1315,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;
@@ -1326,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;
@@ -1364,11 +1356,11 @@ export type CreateProjectPermissions = {
 export type CreateProjectLastRollbackTarget = {};
 
 export const CreateProjectJobStatus = {
+  Pending: "pending",
+  InProgress: "in-progress",
   Succeeded: "succeeded",
   Failed: "failed",
   Skipped: "skipped",
-  Pending: "pending",
-  InProgress: "in-progress",
 } as const;
 export type CreateProjectJobStatus = ClosedEnum<typeof CreateProjectJobStatus>;
 
@@ -1622,6 +1614,7 @@ export type CreateProjectSecurity = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /**
@@ -1804,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
@@ -1873,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
@@ -1954,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);
@@ -2012,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,
@@ -2097,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,
@@ -2147,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,
@@ -2201,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,
@@ -2252,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,
@@ -2294,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,
@@ -2342,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,
@@ -2384,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,
@@ -2433,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
@@ -2484,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
@@ -2575,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<
@@ -2653,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<
@@ -2722,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<
@@ -2791,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<
@@ -2860,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<
@@ -2929,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<
@@ -2998,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<
@@ -3067,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<
@@ -3136,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<
@@ -3205,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<
@@ -3274,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
@@ -3336,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
@@ -3398,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(
@@ -3461,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
@@ -3521,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,
@@ -3598,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<
@@ -3667,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,
@@ -3822,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,
@@ -3852,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
@@ -3912,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,
@@ -3942,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,
@@ -3981,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<
@@ -4050,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,
@@ -4092,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
@@ -4182,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,
@@ -4252,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
@@ -4486,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(
@@ -4562,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,
@@ -4635,7 +5361,25 @@ export namespace CreateProjectLink3$ {
   export type Outbound = CreateProjectLink3$Outbound;
 }
 
-/** @internal */
+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);
@@ -4706,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,
@@ -4782,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
@@ -4851,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,
@@ -4921,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,
@@ -4962,43 +5783,22 @@ export namespace CreateProjectLink$ {
   export type Outbound = CreateProjectLink$Outbound;
 }
 
-/** @internal */
-export const CreateProjectGroup$inboundSchema: z.ZodType<
-  CreateProjectGroup,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  slug: z.string(),
-});
-
-/** @internal */
-export type CreateProjectGroup$Outbound = {
-  id: string;
-  slug: string;
-};
-
-/** @internal */
-export const CreateProjectGroup$outboundSchema: z.ZodType<
-  CreateProjectGroup$Outbound,
-  z.ZodTypeDef,
-  CreateProjectGroup
-> = z.object({
-  id: z.string(),
-  slug: z.string(),
-});
+export function createProjectLinkToJSON(
+  createProjectLink: CreateProjectLink,
+): string {
+  return JSON.stringify(
+    CreateProjectLink$outboundSchema.parse(createProjectLink),
+  );
+}
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace CreateProjectGroup$ {
-  /** @deprecated use `CreateProjectGroup$inboundSchema` instead. */
-  export const inboundSchema = CreateProjectGroup$inboundSchema;
-  /** @deprecated use `CreateProjectGroup$outboundSchema` instead. */
-  export const outboundSchema = CreateProjectGroup$outboundSchema;
-  /** @deprecated use `CreateProjectGroup$Outbound` instead. */
-  export type Outbound = CreateProjectGroup$Outbound;
+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 */
@@ -5008,7 +5808,7 @@ export const CreateProjectMicrofrontends$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => CreateProjectGroup$inboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -5017,7 +5817,7 @@ export const CreateProjectMicrofrontends$inboundSchema: z.ZodType<
 /** @internal */
 export type CreateProjectMicrofrontends$Outbound = {
   updatedAt: number;
-  group: CreateProjectGroup$Outbound;
+  groupIds: Array<string>;
   enabled: boolean;
   isDefaultApp?: boolean | undefined;
   defaultRoute?: string | undefined;
@@ -5030,7 +5830,7 @@ export const CreateProjectMicrofrontends$outboundSchema: z.ZodType<
   CreateProjectMicrofrontends
 > = z.object({
   updatedAt: z.number(),
-  group: z.lazy(() => CreateProjectGroup$outboundSchema),
+  groupIds: z.array(z.string()),
   enabled: z.boolean(),
   isDefaultApp: z.boolean().optional(),
   defaultRoute: z.string().optional(),
@@ -5049,6 +5849,26 @@ export namespace CreateProjectMicrofrontends$ {
   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
@@ -5106,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,
@@ -5142,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,
@@ -5172,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(
@@ -5243,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
@@ -5300,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,
@@ -5331,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,
@@ -5370,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<
@@ -5440,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,
@@ -5482,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(
@@ -5575,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,
@@ -5647,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
@@ -5891,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,
@@ -6003,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(),
@@ -6033,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(),
@@ -6044,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(),
@@ -6192,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;
@@ -6221,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;
@@ -6232,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;
@@ -6381,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(),
@@ -6411,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(),
@@ -6422,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(),
@@ -6477,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,
@@ -6507,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
@@ -6606,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
@@ -6669,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
@@ -6728,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(
@@ -6791,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
@@ -6854,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,
@@ -6892,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,
@@ -6931,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,
@@ -6979,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,
@@ -7045,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,
@@ -7075,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<
@@ -7169,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,
@@ -7199,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,
@@ -7245,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<
@@ -7339,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,
@@ -7377,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,
@@ -7427,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
@@ -7535,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,
@@ -7588,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,
@@ -7645,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,
@@ -7663,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 */
@@ -7677,6 +9132,7 @@ export type CreateProjectSecurity$Outbound = {
   firewallSeawallEnabled?: boolean | undefined;
   ja3Enabled?: boolean | undefined;
   ja4Enabled?: boolean | undefined;
+  firewallBypassIps?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -7697,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(),
 });
 
 /**
@@ -7712,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
@@ -7772,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
@@ -8125,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`,
+  );
+}