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

package/src/models/operations/createprojectenv.ts

@@ -4,7 +4,10 @@
 
 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The type of environment variable
@@ -256,10 +259,10 @@ export type CreateProjectEnvCreatedTarget =
 
 export const CreateProjectEnvCreatedType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type CreateProjectEnvCreatedType = ClosedEnum<
   typeof CreateProjectEnvCreatedType
@@ -605,10 +608,10 @@ export type CreatedTarget =
 
 export const CreatedType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type CreatedType = ClosedEnum<typeof CreatedType>;
 
@@ -1061,6 +1064,20 @@ export namespace Two2$ {
   export type Outbound = Two2$Outbound;
 }
 
+export function two2ToJSON(two2: Two2): string {
+  return JSON.stringify(Two2$outboundSchema.parse(two2));
+}
+
+export function two2FromJSON(
+  jsonString: string,
+): SafeParseResult<Two2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two2' from JSON`,
+  );
+}
+
 /** @internal */
 export const TwoType$inboundSchema: z.ZodNativeEnum<typeof TwoType> = z
   .nativeEnum(TwoType);
@@ -1144,6 +1161,20 @@ export namespace Two1$ {
   export type Outbound = Two1$Outbound;
 }
 
+export function two1ToJSON(two1: Two1): string {
+  return JSON.stringify(Two1$outboundSchema.parse(two1));
+}
+
+export function two1FromJSON(
+  jsonString: string,
+): SafeParseResult<Two1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvRequestBody2$inboundSchema: z.ZodType<
   CreateProjectEnvRequestBody2,
@@ -1182,6 +1213,26 @@ export namespace CreateProjectEnvRequestBody2$ {
   export type Outbound = CreateProjectEnvRequestBody2$Outbound;
 }
 
+export function createProjectEnvRequestBody2ToJSON(
+  createProjectEnvRequestBody2: CreateProjectEnvRequestBody2,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvRequestBody2$outboundSchema.parse(
+      createProjectEnvRequestBody2,
+    ),
+  );
+}
+
+export function createProjectEnvRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvRequestBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnv1Type$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnv1Type
@@ -1275,6 +1326,24 @@ export namespace CreateProjectEnv12$ {
   export type Outbound = CreateProjectEnv12$Outbound;
 }
 
+export function createProjectEnv12ToJSON(
+  createProjectEnv12: CreateProjectEnv12,
+): string {
+  return JSON.stringify(
+    CreateProjectEnv12$outboundSchema.parse(createProjectEnv12),
+  );
+}
+
+export function createProjectEnv12FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnv12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnv12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnv12' from JSON`,
+  );
+}
+
 /** @internal */
 export const OneType$inboundSchema: z.ZodNativeEnum<typeof OneType> = z
   .nativeEnum(OneType);
@@ -1364,6 +1433,24 @@ export namespace CreateProjectEnv11$ {
   export type Outbound = CreateProjectEnv11$Outbound;
 }
 
+export function createProjectEnv11ToJSON(
+  createProjectEnv11: CreateProjectEnv11,
+): string {
+  return JSON.stringify(
+    CreateProjectEnv11$outboundSchema.parse(createProjectEnv11),
+  );
+}
+
+export function createProjectEnv11FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnv11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnv11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnv11' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvRequestBody1$inboundSchema: z.ZodType<
   CreateProjectEnvRequestBody1,
@@ -1402,6 +1489,26 @@ export namespace CreateProjectEnvRequestBody1$ {
   export type Outbound = CreateProjectEnvRequestBody1$Outbound;
 }
 
+export function createProjectEnvRequestBody1ToJSON(
+  createProjectEnvRequestBody1: CreateProjectEnvRequestBody1,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvRequestBody1$outboundSchema.parse(
+      createProjectEnvRequestBody1,
+    ),
+  );
+}
+
+export function createProjectEnvRequestBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvRequestBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvRequestBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvRequestBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvRequestBody$inboundSchema: z.ZodType<
   CreateProjectEnvRequestBody,
@@ -1457,6 +1564,26 @@ export namespace CreateProjectEnvRequestBody$ {
   export type Outbound = CreateProjectEnvRequestBody$Outbound;
 }
 
+export function createProjectEnvRequestBodyToJSON(
+  createProjectEnvRequestBody: CreateProjectEnvRequestBody,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvRequestBody$outboundSchema.parse(
+      createProjectEnvRequestBody,
+    ),
+  );
+}
+
+export function createProjectEnvRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvRequest$inboundSchema: z.ZodType<
   CreateProjectEnvRequest,
@@ -1539,6 +1666,24 @@ export namespace CreateProjectEnvRequest$ {
   export type Outbound = CreateProjectEnvRequest$Outbound;
 }
 
+export function createProjectEnvRequestToJSON(
+  createProjectEnvRequest: CreateProjectEnvRequest,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvRequest$outboundSchema.parse(createProjectEnvRequest),
+  );
+}
+
+export function createProjectEnvRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvTargetProjects2$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvTargetProjects2
@@ -1596,6 +1741,26 @@ export namespace CreateProjectEnvCreatedTarget$ {
   export type Outbound = CreateProjectEnvCreatedTarget$Outbound;
 }
 
+export function createProjectEnvCreatedTargetToJSON(
+  createProjectEnvCreatedTarget: CreateProjectEnvCreatedTarget,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvCreatedTarget$outboundSchema.parse(
+      createProjectEnvCreatedTarget,
+    ),
+  );
+}
+
+export function createProjectEnvCreatedTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvCreatedTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvCreatedTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvCreatedTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvCreatedType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvCreatedType
@@ -1688,6 +1853,27 @@ export namespace CreateProjectEnvContentHintProjects15$ {
   export type Outbound = CreateProjectEnvContentHintProjects15$Outbound;
 }
 
+export function createProjectEnvContentHintProjects15ToJSON(
+  createProjectEnvContentHintProjects15: CreateProjectEnvContentHintProjects15,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects15$outboundSchema.parse(
+      createProjectEnvContentHintProjects15,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects15FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects15' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated214Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1768,6 +1954,27 @@ export namespace CreateProjectEnvContentHintProjects14$ {
   export type Outbound = CreateProjectEnvContentHintProjects14$Outbound;
 }
 
+export function createProjectEnvContentHintProjects14ToJSON(
+  createProjectEnvContentHintProjects14: CreateProjectEnvContentHintProjects14,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects14$outboundSchema.parse(
+      createProjectEnvContentHintProjects14,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects14FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects14' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated213Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1839,6 +2046,27 @@ export namespace CreateProjectEnvContentHintProjects13$ {
   export type Outbound = CreateProjectEnvContentHintProjects13$Outbound;
 }
 
+export function createProjectEnvContentHintProjects13ToJSON(
+  createProjectEnvContentHintProjects13: CreateProjectEnvContentHintProjects13,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects13$outboundSchema.parse(
+      createProjectEnvContentHintProjects13,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects13FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects13' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated212Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1910,6 +2138,27 @@ export namespace CreateProjectEnvContentHintProjects12$ {
   export type Outbound = CreateProjectEnvContentHintProjects12$Outbound;
 }
 
+export function createProjectEnvContentHintProjects12ToJSON(
+  createProjectEnvContentHintProjects12: CreateProjectEnvContentHintProjects12,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects12$outboundSchema.parse(
+      createProjectEnvContentHintProjects12,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects12FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects12' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated211Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1981,6 +2230,27 @@ export namespace CreateProjectEnvContentHintProjects11$ {
   export type Outbound = CreateProjectEnvContentHintProjects11$Outbound;
 }
 
+export function createProjectEnvContentHintProjects11ToJSON(
+  createProjectEnvContentHintProjects11: CreateProjectEnvContentHintProjects11,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects11$outboundSchema.parse(
+      createProjectEnvContentHintProjects11,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects11FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects11' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated210Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2052,6 +2322,27 @@ export namespace CreateProjectEnvContentHintProjects10$ {
   export type Outbound = CreateProjectEnvContentHintProjects10$Outbound;
 }
 
+export function createProjectEnvContentHintProjects10ToJSON(
+  createProjectEnvContentHintProjects10: CreateProjectEnvContentHintProjects10,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects10$outboundSchema.parse(
+      createProjectEnvContentHintProjects10,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects10FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects10' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated29Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2123,6 +2414,27 @@ export namespace CreateProjectEnvContentHintProjects9$ {
   export type Outbound = CreateProjectEnvContentHintProjects9$Outbound;
 }
 
+export function createProjectEnvContentHintProjects9ToJSON(
+  createProjectEnvContentHintProjects9: CreateProjectEnvContentHintProjects9,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects9$outboundSchema.parse(
+      createProjectEnvContentHintProjects9,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects9FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects9' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated28Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2194,6 +2506,27 @@ export namespace CreateProjectEnvContentHintProjects8$ {
   export type Outbound = CreateProjectEnvContentHintProjects8$Outbound;
 }
 
+export function createProjectEnvContentHintProjects8ToJSON(
+  createProjectEnvContentHintProjects8: CreateProjectEnvContentHintProjects8,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects8$outboundSchema.parse(
+      createProjectEnvContentHintProjects8,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects8FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects8' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated27Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2265,6 +2598,27 @@ export namespace CreateProjectEnvContentHintProjects7$ {
   export type Outbound = CreateProjectEnvContentHintProjects7$Outbound;
 }
 
+export function createProjectEnvContentHintProjects7ToJSON(
+  createProjectEnvContentHintProjects7: CreateProjectEnvContentHintProjects7,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects7$outboundSchema.parse(
+      createProjectEnvContentHintProjects7,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects7FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects7' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated26Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2336,6 +2690,27 @@ export namespace CreateProjectEnvContentHintProjects6$ {
   export type Outbound = CreateProjectEnvContentHintProjects6$Outbound;
 }
 
+export function createProjectEnvContentHintProjects6ToJSON(
+  createProjectEnvContentHintProjects6: CreateProjectEnvContentHintProjects6,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects6$outboundSchema.parse(
+      createProjectEnvContentHintProjects6,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects6FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects6' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated25Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2407,6 +2782,27 @@ export namespace CreateProjectEnvContentHintProjects5$ {
   export type Outbound = CreateProjectEnvContentHintProjects5$Outbound;
 }
 
+export function createProjectEnvContentHintProjects5ToJSON(
+  createProjectEnvContentHintProjects5: CreateProjectEnvContentHintProjects5,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects5$outboundSchema.parse(
+      createProjectEnvContentHintProjects5,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects5FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects5' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated24Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2478,6 +2874,27 @@ export namespace CreateProjectEnvContentHintProjects4$ {
   export type Outbound = CreateProjectEnvContentHintProjects4$Outbound;
 }
 
+export function createProjectEnvContentHintProjects4ToJSON(
+  createProjectEnvContentHintProjects4: CreateProjectEnvContentHintProjects4,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects4$outboundSchema.parse(
+      createProjectEnvContentHintProjects4,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects4FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects4' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated23Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2549,6 +2966,27 @@ export namespace CreateProjectEnvContentHintProjects3$ {
   export type Outbound = CreateProjectEnvContentHintProjects3$Outbound;
 }
 
+export function createProjectEnvContentHintProjects3ToJSON(
+  createProjectEnvContentHintProjects3: CreateProjectEnvContentHintProjects3,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects3$outboundSchema.parse(
+      createProjectEnvContentHintProjects3,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects3FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated22Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2620,6 +3058,27 @@ export namespace CreateProjectEnvContentHintProjects2$ {
   export type Outbound = CreateProjectEnvContentHintProjects2$Outbound;
 }
 
+export function createProjectEnvContentHintProjects2ToJSON(
+  createProjectEnvContentHintProjects2: CreateProjectEnvContentHintProjects2,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects2$outboundSchema.parse(
+      createProjectEnvContentHintProjects2,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated2Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2691,6 +3150,27 @@ export namespace CreateProjectEnvContentHintProjects1$ {
   export type Outbound = CreateProjectEnvContentHintProjects1$Outbound;
 }
 
+export function createProjectEnvContentHintProjects1ToJSON(
+  createProjectEnvContentHintProjects1: CreateProjectEnvContentHintProjects1,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHintProjects1$outboundSchema.parse(
+      createProjectEnvContentHintProjects1,
+    ),
+  );
+}
+
+export function createProjectEnvContentHintProjects1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHintProjects1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvContentHintProjects1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHintProjects1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvCreatedContentHint$inboundSchema: z.ZodType<
   CreateProjectEnvCreatedContentHint,
@@ -2769,6 +3249,27 @@ export namespace CreateProjectEnvCreatedContentHint$ {
   export type Outbound = CreateProjectEnvCreatedContentHint$Outbound;
 }
 
+export function createProjectEnvCreatedContentHintToJSON(
+  createProjectEnvCreatedContentHint: CreateProjectEnvCreatedContentHint,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvCreatedContentHint$outboundSchema.parse(
+      createProjectEnvCreatedContentHint,
+    ),
+  );
+}
+
+export function createProjectEnvCreatedContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvCreatedContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvCreatedContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvCreatedContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvCreatedProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectEnvCreatedProjectsResponseType> = z
@@ -2832,6 +3333,33 @@ export namespace CreateProjectEnvCreatedInternalContentHint$ {
   export type Outbound = CreateProjectEnvCreatedInternalContentHint$Outbound;
 }
 
+export function createProjectEnvCreatedInternalContentHintToJSON(
+  createProjectEnvCreatedInternalContentHint:
+    CreateProjectEnvCreatedInternalContentHint,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvCreatedInternalContentHint$outboundSchema.parse(
+      createProjectEnvCreatedInternalContentHint,
+    ),
+  );
+}
+
+export function createProjectEnvCreatedInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateProjectEnvCreatedInternalContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectEnvCreatedInternalContentHint$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateProjectEnvCreatedInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const Created2$inboundSchema: z.ZodType<
   Created2,
@@ -2994,6 +3522,20 @@ export namespace Created2$ {
   export type Outbound = Created2$Outbound;
 }
 
+export function created2ToJSON(created2: Created2): string {
+  return JSON.stringify(Created2$outboundSchema.parse(created2));
+}
+
+export function created2FromJSON(
+  jsonString: string,
+): SafeParseResult<Created2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Created2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Created2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvTarget2$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvTarget2
@@ -3072,6 +3614,20 @@ export namespace CreatedTarget$ {
   export type Outbound = CreatedTarget$Outbound;
 }
 
+export function createdTargetToJSON(createdTarget: CreatedTarget): string {
+  return JSON.stringify(CreatedTarget$outboundSchema.parse(createdTarget));
+}
+
+export function createdTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatedTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatedTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatedTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatedType$inboundSchema: z.ZodNativeEnum<typeof CreatedType> = z
   .nativeEnum(CreatedType);
@@ -3160,6 +3716,26 @@ export namespace CreateProjectEnvContentHint15$ {
   export type Outbound = CreateProjectEnvContentHint15$Outbound;
 }
 
+export function createProjectEnvContentHint15ToJSON(
+  createProjectEnvContentHint15: CreateProjectEnvContentHint15,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint15$outboundSchema.parse(
+      createProjectEnvContentHint15,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint15FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint15' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated114Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3238,6 +3814,26 @@ export namespace CreateProjectEnvContentHint14$ {
   export type Outbound = CreateProjectEnvContentHint14$Outbound;
 }
 
+export function createProjectEnvContentHint14ToJSON(
+  createProjectEnvContentHint14: CreateProjectEnvContentHint14,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint14$outboundSchema.parse(
+      createProjectEnvContentHint14,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint14FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint14' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated113Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3307,6 +3903,26 @@ export namespace CreateProjectEnvContentHint13$ {
   export type Outbound = CreateProjectEnvContentHint13$Outbound;
 }
 
+export function createProjectEnvContentHint13ToJSON(
+  createProjectEnvContentHint13: CreateProjectEnvContentHint13,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint13$outboundSchema.parse(
+      createProjectEnvContentHint13,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint13FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint13' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated112Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3376,6 +3992,26 @@ export namespace CreateProjectEnvContentHint12$ {
   export type Outbound = CreateProjectEnvContentHint12$Outbound;
 }
 
+export function createProjectEnvContentHint12ToJSON(
+  createProjectEnvContentHint12: CreateProjectEnvContentHint12,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint12$outboundSchema.parse(
+      createProjectEnvContentHint12,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint12FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint12' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated111Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3445,6 +4081,26 @@ export namespace CreateProjectEnvContentHint11$ {
   export type Outbound = CreateProjectEnvContentHint11$Outbound;
 }
 
+export function createProjectEnvContentHint11ToJSON(
+  createProjectEnvContentHint11: CreateProjectEnvContentHint11,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint11$outboundSchema.parse(
+      createProjectEnvContentHint11,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated110Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3514,6 +4170,26 @@ export namespace CreateProjectEnvContentHint10$ {
   export type Outbound = CreateProjectEnvContentHint10$Outbound;
 }
 
+export function createProjectEnvContentHint10ToJSON(
+  createProjectEnvContentHint10: CreateProjectEnvContentHint10,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint10$outboundSchema.parse(
+      createProjectEnvContentHint10,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated19Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3583,6 +4259,26 @@ export namespace CreateProjectEnvContentHint9$ {
   export type Outbound = CreateProjectEnvContentHint9$Outbound;
 }
 
+export function createProjectEnvContentHint9ToJSON(
+  createProjectEnvContentHint9: CreateProjectEnvContentHint9,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint9$outboundSchema.parse(
+      createProjectEnvContentHint9,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreated1Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3652,6 +4348,26 @@ export namespace CreateProjectEnvContentHint8$ {
   export type Outbound = CreateProjectEnvContentHint8$Outbound;
 }
 
+export function createProjectEnvContentHint8ToJSON(
+  createProjectEnvContentHint8: CreateProjectEnvContentHint8,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint8$outboundSchema.parse(
+      createProjectEnvContentHint8,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyCreatedType$inboundSchema:
   z.ZodNativeEnum<
@@ -3721,6 +4437,26 @@ export namespace CreateProjectEnvContentHint7$ {
   export type Outbound = CreateProjectEnvContentHint7$Outbound;
 }
 
+export function createProjectEnvContentHint7ToJSON(
+  createProjectEnvContentHint7: CreateProjectEnvContentHint7,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint7$outboundSchema.parse(
+      createProjectEnvContentHint7,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -3790,6 +4526,26 @@ export namespace CreateProjectEnvContentHint6$ {
   export type Outbound = CreateProjectEnvContentHint6$Outbound;
 }
 
+export function createProjectEnvContentHint6ToJSON(
+  createProjectEnvContentHint6: CreateProjectEnvContentHint6,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint6$outboundSchema.parse(
+      createProjectEnvContentHint6,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -3859,6 +4615,26 @@ export namespace CreateProjectEnvContentHint5$ {
   export type Outbound = CreateProjectEnvContentHint5$Outbound;
 }
 
+export function createProjectEnvContentHint5ToJSON(
+  createProjectEnvContentHint5: CreateProjectEnvContentHint5,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint5$outboundSchema.parse(
+      createProjectEnvContentHint5,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponse201Type$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectEnvContentHintProjectsResponse201Type> = z
@@ -3921,6 +4697,26 @@ export namespace CreateProjectEnvContentHint4$ {
   export type Outbound = CreateProjectEnvContentHint4$Outbound;
 }
 
+export function createProjectEnvContentHint4ToJSON(
+  createProjectEnvContentHint4: CreateProjectEnvContentHint4,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint4$outboundSchema.parse(
+      createProjectEnvContentHint4,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectEnvContentHintProjectsResponseType> = z
@@ -3983,6 +4779,26 @@ export namespace CreateProjectEnvContentHint3$ {
   export type Outbound = CreateProjectEnvContentHint3$Outbound;
 }
 
+export function createProjectEnvContentHint3ToJSON(
+  createProjectEnvContentHint3: CreateProjectEnvContentHint3,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint3$outboundSchema.parse(
+      createProjectEnvContentHint3,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectEnvContentHintProjectsType> = z
@@ -4045,6 +4861,26 @@ export namespace CreateProjectEnvContentHint2$ {
   export type Outbound = CreateProjectEnvContentHint2$Outbound;
 }
 
+export function createProjectEnvContentHint2ToJSON(
+  createProjectEnvContentHint2: CreateProjectEnvContentHint2,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint2$outboundSchema.parse(
+      createProjectEnvContentHint2,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvContentHintType
@@ -4105,6 +4941,26 @@ export namespace CreateProjectEnvContentHint1$ {
   export type Outbound = CreateProjectEnvContentHint1$Outbound;
 }
 
+export function createProjectEnvContentHint1ToJSON(
+  createProjectEnvContentHint1: CreateProjectEnvContentHint1,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvContentHint1$outboundSchema.parse(
+      createProjectEnvContentHint1,
+    ),
+  );
+}
+
+export function createProjectEnvContentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatedContentHint$inboundSchema: z.ZodType<
   CreatedContentHint,
@@ -4182,6 +5038,24 @@ export namespace CreatedContentHint$ {
   export type Outbound = CreatedContentHint$Outbound;
 }
 
+export function createdContentHintToJSON(
+  createdContentHint: CreatedContentHint,
+): string {
+  return JSON.stringify(
+    CreatedContentHint$outboundSchema.parse(createdContentHint),
+  );
+}
+
+export function createdContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatedContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatedContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatedContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvCreatedProjectsType$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvCreatedProjectsType
@@ -4244,6 +5118,24 @@ export namespace CreatedInternalContentHint$ {
   export type Outbound = CreatedInternalContentHint$Outbound;
 }
 
+export function createdInternalContentHintToJSON(
+  createdInternalContentHint: CreatedInternalContentHint,
+): string {
+  return JSON.stringify(
+    CreatedInternalContentHint$outboundSchema.parse(createdInternalContentHint),
+  );
+}
+
+export function createdInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatedInternalContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatedInternalContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatedInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const Created1$inboundSchema: z.ZodType<
   Created1,
@@ -4403,6 +5295,20 @@ export namespace Created1$ {
   export type Outbound = Created1$Outbound;
 }
 
+export function created1ToJSON(created1: Created1): string {
+  return JSON.stringify(Created1$outboundSchema.parse(created1));
+}
+
+export function created1FromJSON(
+  jsonString: string,
+): SafeParseResult<Created1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Created1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Created1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Created$inboundSchema: z.ZodType<Created, z.ZodTypeDef, unknown> =
   z.union([
@@ -4436,6 +5342,20 @@ export namespace Created$ {
   export type Outbound = Created$Outbound;
 }
 
+export function createdToJSON(created: Created): string {
+  return JSON.stringify(Created$outboundSchema.parse(created));
+}
+
+export function createdFromJSON(
+  jsonString: string,
+): SafeParseResult<Created, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Created$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Created' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvValue2$inboundSchema: z.ZodNativeEnum<
   typeof CreateProjectEnvValue2
@@ -4487,6 +5407,24 @@ export namespace CreateProjectEnvValue$ {
   export type Outbound = CreateProjectEnvValue$Outbound;
 }
 
+export function createProjectEnvValueToJSON(
+  createProjectEnvValue: CreateProjectEnvValue,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvValue$outboundSchema.parse(createProjectEnvValue),
+  );
+}
+
+export function createProjectEnvValueFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvValue' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvTargetProjectsResponse2$inboundSchema:
   z.ZodNativeEnum<typeof CreateProjectEnvTargetProjectsResponse2> = z
@@ -4567,6 +5505,24 @@ export namespace CreateProjectEnvTarget$ {
   export type Outbound = CreateProjectEnvTarget$Outbound;
 }
 
+export function createProjectEnvTargetToJSON(
+  createProjectEnvTarget: CreateProjectEnvTarget,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvTarget$outboundSchema.parse(createProjectEnvTarget),
+  );
+}
+
+export function createProjectEnvTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvError$inboundSchema: z.ZodType<
   CreateProjectEnvError,
@@ -4641,6 +5597,24 @@ export namespace CreateProjectEnvError$ {
   export type Outbound = CreateProjectEnvError$Outbound;
 }
 
+export function createProjectEnvErrorToJSON(
+  createProjectEnvError: CreateProjectEnvError,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvError$outboundSchema.parse(createProjectEnvError),
+  );
+}
+
+export function createProjectEnvErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvError' from JSON`,
+  );
+}
+
 /** @internal */
 export const Failed$inboundSchema: z.ZodType<Failed, z.ZodTypeDef, unknown> = z
   .object({
@@ -4674,6 +5648,20 @@ export namespace Failed$ {
   export type Outbound = Failed$Outbound;
 }
 
+export function failedToJSON(failed: Failed): string {
+  return JSON.stringify(Failed$outboundSchema.parse(failed));
+}
+
+export function failedFromJSON(
+  jsonString: string,
+): SafeParseResult<Failed, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Failed$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Failed' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectEnvResponseBody$inboundSchema: z.ZodType<
   CreateProjectEnvResponseBody,
@@ -4718,3 +5706,23 @@ export namespace CreateProjectEnvResponseBody$ {
   /** @deprecated use `CreateProjectEnvResponseBody$Outbound` instead. */
   export type Outbound = CreateProjectEnvResponseBody$Outbound;
 }
+
+export function createProjectEnvResponseBodyToJSON(
+  createProjectEnvResponseBody: CreateProjectEnvResponseBody,
+): string {
+  return JSON.stringify(
+    CreateProjectEnvResponseBody$outboundSchema.parse(
+      createProjectEnvResponseBody,
+    ),
+  );
+}
+
+export function createProjectEnvResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectEnvResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectEnvResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectEnvResponseBody' from JSON`,
+  );
+}