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

package/src/models/operations/editprojectenv.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";
 
 export const EditProjectEnvTarget = {
   Production: "production",
@@ -91,10 +94,10 @@ export type EditProjectEnvResponseBodyTarget =
 
 export const EditProjectEnvResponseBodyType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type EditProjectEnvResponseBodyType = ClosedEnum<
   typeof EditProjectEnvResponseBodyType
@@ -503,6 +506,24 @@ export namespace EditProjectEnvRequestBody$ {
   export type Outbound = EditProjectEnvRequestBody$Outbound;
 }
 
+export function editProjectEnvRequestBodyToJSON(
+  editProjectEnvRequestBody: EditProjectEnvRequestBody,
+): string {
+  return JSON.stringify(
+    EditProjectEnvRequestBody$outboundSchema.parse(editProjectEnvRequestBody),
+  );
+}
+
+export function editProjectEnvRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvRequest$inboundSchema: z.ZodType<
   EditProjectEnvRequest,
@@ -560,6 +581,24 @@ export namespace EditProjectEnvRequest$ {
   export type Outbound = EditProjectEnvRequest$Outbound;
 }
 
+export function editProjectEnvRequestToJSON(
+  editProjectEnvRequest: EditProjectEnvRequest,
+): string {
+  return JSON.stringify(
+    EditProjectEnvRequest$outboundSchema.parse(editProjectEnvRequest),
+  );
+}
+
+export function editProjectEnvRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBody2$inboundSchema: z.ZodType<
   EditProjectEnvResponseBody2,
@@ -590,6 +629,26 @@ export namespace EditProjectEnvResponseBody2$ {
   export type Outbound = EditProjectEnvResponseBody2$Outbound;
 }
 
+export function editProjectEnvResponseBody2ToJSON(
+  editProjectEnvResponseBody2: EditProjectEnvResponseBody2,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBody2$outboundSchema.parse(
+      editProjectEnvResponseBody2,
+    ),
+  );
+}
+
+export function editProjectEnvResponseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvTarget2$inboundSchema: z.ZodNativeEnum<
   typeof EditProjectEnvTarget2
@@ -641,6 +700,26 @@ export namespace EditProjectEnvResponseBodyTarget$ {
   export type Outbound = EditProjectEnvResponseBodyTarget$Outbound;
 }
 
+export function editProjectEnvResponseBodyTargetToJSON(
+  editProjectEnvResponseBodyTarget: EditProjectEnvResponseBodyTarget,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBodyTarget$outboundSchema.parse(
+      editProjectEnvResponseBodyTarget,
+    ),
+  );
+}
+
+export function editProjectEnvResponseBodyTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvResponseBodyTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvResponseBodyTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvResponseBodyTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBodyType$inboundSchema: z.ZodNativeEnum<
   typeof EditProjectEnvResponseBodyType
@@ -731,6 +810,26 @@ export namespace EditProjectEnvContentHint15$ {
   export type Outbound = EditProjectEnvContentHint15$Outbound;
 }
 
+export function editProjectEnvContentHint15ToJSON(
+  editProjectEnvContentHint15: EditProjectEnvContentHint15,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint15$outboundSchema.parse(
+      editProjectEnvContentHint15,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint15FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint15' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody114Type$inboundSchema:
   z.ZodNativeEnum<
@@ -809,6 +908,26 @@ export namespace EditProjectEnvContentHint14$ {
   export type Outbound = EditProjectEnvContentHint14$Outbound;
 }
 
+export function editProjectEnvContentHint14ToJSON(
+  editProjectEnvContentHint14: EditProjectEnvContentHint14,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint14$outboundSchema.parse(
+      editProjectEnvContentHint14,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint14FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint14' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody113Type$inboundSchema:
   z.ZodNativeEnum<
@@ -878,6 +997,26 @@ export namespace EditProjectEnvContentHint13$ {
   export type Outbound = EditProjectEnvContentHint13$Outbound;
 }
 
+export function editProjectEnvContentHint13ToJSON(
+  editProjectEnvContentHint13: EditProjectEnvContentHint13,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint13$outboundSchema.parse(
+      editProjectEnvContentHint13,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint13FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint13' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody112Type$inboundSchema:
   z.ZodNativeEnum<
@@ -947,6 +1086,26 @@ export namespace EditProjectEnvContentHint12$ {
   export type Outbound = EditProjectEnvContentHint12$Outbound;
 }
 
+export function editProjectEnvContentHint12ToJSON(
+  editProjectEnvContentHint12: EditProjectEnvContentHint12,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint12$outboundSchema.parse(
+      editProjectEnvContentHint12,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint12FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint12' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody111Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1016,6 +1175,26 @@ export namespace EditProjectEnvContentHint11$ {
   export type Outbound = EditProjectEnvContentHint11$Outbound;
 }
 
+export function editProjectEnvContentHint11ToJSON(
+  editProjectEnvContentHint11: EditProjectEnvContentHint11,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint11$outboundSchema.parse(
+      editProjectEnvContentHint11,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody110Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1085,6 +1264,26 @@ export namespace EditProjectEnvContentHint10$ {
   export type Outbound = EditProjectEnvContentHint10$Outbound;
 }
 
+export function editProjectEnvContentHint10ToJSON(
+  editProjectEnvContentHint10: EditProjectEnvContentHint10,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint10$outboundSchema.parse(
+      editProjectEnvContentHint10,
+    ),
+  );
+}
+
+export function editProjectEnvContentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody19Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1154,6 +1353,24 @@ export namespace EditProjectEnvContentHint9$ {
   export type Outbound = EditProjectEnvContentHint9$Outbound;
 }
 
+export function editProjectEnvContentHint9ToJSON(
+  editProjectEnvContentHint9: EditProjectEnvContentHint9,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint9$outboundSchema.parse(editProjectEnvContentHint9),
+  );
+}
+
+export function editProjectEnvContentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody18Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1223,6 +1440,24 @@ export namespace EditProjectEnvContentHint8$ {
   export type Outbound = EditProjectEnvContentHint8$Outbound;
 }
 
+export function editProjectEnvContentHint8ToJSON(
+  editProjectEnvContentHint8: EditProjectEnvContentHint8,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint8$outboundSchema.parse(editProjectEnvContentHint8),
+  );
+}
+
+export function editProjectEnvContentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBody1Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1292,6 +1527,24 @@ export namespace EditProjectEnvContentHint7$ {
   export type Outbound = EditProjectEnvContentHint7$Outbound;
 }
 
+export function editProjectEnvContentHint7ToJSON(
+  editProjectEnvContentHint7: EditProjectEnvContentHint7,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint7$outboundSchema.parse(editProjectEnvContentHint7),
+  );
+}
+
+export function editProjectEnvContentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -1361,6 +1614,24 @@ export namespace EditProjectEnvContentHint6$ {
   export type Outbound = EditProjectEnvContentHint6$Outbound;
 }
 
+export function editProjectEnvContentHint6ToJSON(
+  editProjectEnvContentHint6: EditProjectEnvContentHint6,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint6$outboundSchema.parse(editProjectEnvContentHint6),
+  );
+}
+
+export function editProjectEnvContentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -1430,6 +1701,24 @@ export namespace EditProjectEnvContentHint5$ {
   export type Outbound = EditProjectEnvContentHint5$Outbound;
 }
 
+export function editProjectEnvContentHint5ToJSON(
+  editProjectEnvContentHint5: EditProjectEnvContentHint5,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint5$outboundSchema.parse(editProjectEnvContentHint5),
+  );
+}
+
+export function editProjectEnvContentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof EditProjectEnvContentHintProjectsResponse200Type> = z
@@ -1492,6 +1781,24 @@ export namespace EditProjectEnvContentHint4$ {
   export type Outbound = EditProjectEnvContentHint4$Outbound;
 }
 
+export function editProjectEnvContentHint4ToJSON(
+  editProjectEnvContentHint4: EditProjectEnvContentHint4,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint4$outboundSchema.parse(editProjectEnvContentHint4),
+  );
+}
+
+export function editProjectEnvContentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof EditProjectEnvContentHintProjectsResponseType> = z
@@ -1554,6 +1861,24 @@ export namespace EditProjectEnvContentHint3$ {
   export type Outbound = EditProjectEnvContentHint3$Outbound;
 }
 
+export function editProjectEnvContentHint3ToJSON(
+  editProjectEnvContentHint3: EditProjectEnvContentHint3,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint3$outboundSchema.parse(editProjectEnvContentHint3),
+  );
+}
+
+export function editProjectEnvContentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof EditProjectEnvContentHintProjectsType> = z.nativeEnum(
@@ -1617,6 +1942,24 @@ export namespace EditProjectEnvContentHint2$ {
   export type Outbound = EditProjectEnvContentHint2$Outbound;
 }
 
+export function editProjectEnvContentHint2ToJSON(
+  editProjectEnvContentHint2: EditProjectEnvContentHint2,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint2$outboundSchema.parse(editProjectEnvContentHint2),
+  );
+}
+
+export function editProjectEnvContentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof EditProjectEnvContentHintType
@@ -1677,6 +2020,24 @@ export namespace EditProjectEnvContentHint1$ {
   export type Outbound = EditProjectEnvContentHint1$Outbound;
 }
 
+export function editProjectEnvContentHint1ToJSON(
+  editProjectEnvContentHint1: EditProjectEnvContentHint1,
+): string {
+  return JSON.stringify(
+    EditProjectEnvContentHint1$outboundSchema.parse(editProjectEnvContentHint1),
+  );
+}
+
+export function editProjectEnvContentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBodyContentHint$inboundSchema: z.ZodType<
   EditProjectEnvResponseBodyContentHint,
@@ -1756,6 +2117,27 @@ export namespace EditProjectEnvResponseBodyContentHint$ {
   export type Outbound = EditProjectEnvResponseBodyContentHint$Outbound;
 }
 
+export function editProjectEnvResponseBodyContentHintToJSON(
+  editProjectEnvResponseBodyContentHint: EditProjectEnvResponseBodyContentHint,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBodyContentHint$outboundSchema.parse(
+      editProjectEnvResponseBodyContentHint,
+    ),
+  );
+}
+
+export function editProjectEnvResponseBodyContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvResponseBodyContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EditProjectEnvResponseBodyContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvResponseBodyContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBodyProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof EditProjectEnvResponseBodyProjectsType> = z.nativeEnum(
@@ -1823,6 +2205,33 @@ export namespace EditProjectEnvResponseBodyInternalContentHint$ {
   export type Outbound = EditProjectEnvResponseBodyInternalContentHint$Outbound;
 }
 
+export function editProjectEnvResponseBodyInternalContentHintToJSON(
+  editProjectEnvResponseBodyInternalContentHint:
+    EditProjectEnvResponseBodyInternalContentHint,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBodyInternalContentHint$outboundSchema.parse(
+      editProjectEnvResponseBodyInternalContentHint,
+    ),
+  );
+}
+
+export function editProjectEnvResponseBodyInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  EditProjectEnvResponseBodyInternalContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EditProjectEnvResponseBodyInternalContentHint$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'EditProjectEnvResponseBodyInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBody1$inboundSchema: z.ZodType<
   EditProjectEnvResponseBody1,
@@ -1975,6 +2384,26 @@ export namespace EditProjectEnvResponseBody1$ {
   export type Outbound = EditProjectEnvResponseBody1$Outbound;
 }
 
+export function editProjectEnvResponseBody1ToJSON(
+  editProjectEnvResponseBody1: EditProjectEnvResponseBody1,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBody1$outboundSchema.parse(
+      editProjectEnvResponseBody1,
+    ),
+  );
+}
+
+export function editProjectEnvResponseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvResponseBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const EditProjectEnvResponseBody$inboundSchema: z.ZodType<
   EditProjectEnvResponseBody,
@@ -2012,3 +2441,21 @@ export namespace EditProjectEnvResponseBody$ {
   /** @deprecated use `EditProjectEnvResponseBody$Outbound` instead. */
   export type Outbound = EditProjectEnvResponseBody$Outbound;
 }
+
+export function editProjectEnvResponseBodyToJSON(
+  editProjectEnvResponseBody: EditProjectEnvResponseBody,
+): string {
+  return JSON.stringify(
+    EditProjectEnvResponseBody$outboundSchema.parse(editProjectEnvResponseBody),
+  );
+}
+
+export function editProjectEnvResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<EditProjectEnvResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EditProjectEnvResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EditProjectEnvResponseBody' from JSON`,
+  );
+}