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

package/src/models/operations/filterprojectenvs.ts

@@ -3,13 +3,16 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import {
   Pagination,
   Pagination$inboundSchema,
   Pagination$Outbound,
   Pagination$outboundSchema,
 } from "../components/pagination.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * If true, the environment variable value will be decrypted
@@ -1179,6 +1182,24 @@ export namespace FilterProjectEnvsRequest$ {
   export type Outbound = FilterProjectEnvsRequest$Outbound;
 }
 
+export function filterProjectEnvsRequestToJSON(
+  filterProjectEnvsRequest: FilterProjectEnvsRequest,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsRequest$outboundSchema.parse(filterProjectEnvsRequest),
+  );
+}
+
+export function filterProjectEnvsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsTargetProjectsResponse2$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsTargetProjectsResponse2> = z
@@ -1266,6 +1287,33 @@ export namespace FilterProjectEnvsResponseBodyProjectsResponseTarget$ {
     FilterProjectEnvsResponseBodyProjectsResponseTarget$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyProjectsResponseTargetToJSON(
+  filterProjectEnvsResponseBodyProjectsResponseTarget:
+    FilterProjectEnvsResponseBodyProjectsResponseTarget,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyProjectsResponseTarget$outboundSchema.parse(
+      filterProjectEnvsResponseBodyProjectsResponseTarget,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyProjectsResponseTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyProjectsResponseTarget,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyProjectsResponseTarget$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsResponseBodyProjectsResponseTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsResponseBodyProjectsResponse200Type> =
@@ -1363,6 +1411,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse15$ {
     FilterProjectEnvsContentHintProjectsResponse15$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse15ToJSON(
+  filterProjectEnvsContentHintProjectsResponse15:
+    FilterProjectEnvsContentHintProjectsResponse15,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse15$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse15,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse15FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse15,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse15$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse15' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs14Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1446,6 +1521,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse14$ {
     FilterProjectEnvsContentHintProjectsResponse14$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse14ToJSON(
+  filterProjectEnvsContentHintProjectsResponse14:
+    FilterProjectEnvsContentHintProjectsResponse14,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse14$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse14,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse14FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse14,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse14$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse14' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs13Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1520,6 +1622,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse13$ {
     FilterProjectEnvsContentHintProjectsResponse13$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse13ToJSON(
+  filterProjectEnvsContentHintProjectsResponse13:
+    FilterProjectEnvsContentHintProjectsResponse13,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse13$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse13,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse13FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse13,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse13$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse13' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs12Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1594,6 +1723,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse12$ {
     FilterProjectEnvsContentHintProjectsResponse12$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse12ToJSON(
+  filterProjectEnvsContentHintProjectsResponse12:
+    FilterProjectEnvsContentHintProjectsResponse12,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse12$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse12,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse12FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse12,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse12$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse12' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs11Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1668,6 +1824,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse11$ {
     FilterProjectEnvsContentHintProjectsResponse11$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse11ToJSON(
+  filterProjectEnvsContentHintProjectsResponse11:
+    FilterProjectEnvsContentHintProjectsResponse11,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse11$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse11,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse11FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse11,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse11$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse11' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs10Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1742,6 +1925,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse10$ {
     FilterProjectEnvsContentHintProjectsResponse10$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse10ToJSON(
+  filterProjectEnvsContentHintProjectsResponse10:
+    FilterProjectEnvsContentHintProjectsResponse10,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse10$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse10,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse10FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse10,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse10$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse10' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs9Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1815,6 +2025,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse9$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse9$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse9ToJSON(
+  filterProjectEnvsContentHintProjectsResponse9:
+    FilterProjectEnvsContentHintProjectsResponse9,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse9$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse9,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse9FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse9,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse9$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse9' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs8Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1888,6 +2125,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse8$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse8$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse8ToJSON(
+  filterProjectEnvsContentHintProjectsResponse8:
+    FilterProjectEnvsContentHintProjectsResponse8,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse8$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse8,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse8FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse8,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse8$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse8' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs7Type$inboundSchema:
   z.ZodNativeEnum<
@@ -1961,6 +2225,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse7$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse7$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse7ToJSON(
+  filterProjectEnvsContentHintProjectsResponse7:
+    FilterProjectEnvsContentHintProjectsResponse7,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse7$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse7,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse7FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse7,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse7$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse7' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs6Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2034,6 +2325,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse6$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse6$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse6ToJSON(
+  filterProjectEnvsContentHintProjectsResponse6:
+    FilterProjectEnvsContentHintProjectsResponse6,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse6$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse6,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse6FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse6,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse6$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse6' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs5Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2107,6 +2425,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse5$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse5$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse5ToJSON(
+  filterProjectEnvsContentHintProjectsResponse5:
+    FilterProjectEnvsContentHintProjectsResponse5,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse5$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse5,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse5FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse5,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse5$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse5' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs4Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2180,6 +2525,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse4$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse4$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse4ToJSON(
+  filterProjectEnvsContentHintProjectsResponse4:
+    FilterProjectEnvsContentHintProjectsResponse4,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse4$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse4,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse4FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse4,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse4$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse4' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Envs3Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2253,6 +2625,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse3$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse3$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse3ToJSON(
+  filterProjectEnvsContentHintProjectsResponse3:
+    FilterProjectEnvsContentHintProjectsResponse3,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse3$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse3,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse3FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse3,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse3$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse3' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3EnvsType$inboundSchema:
   z.ZodNativeEnum<
@@ -2326,6 +2725,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse2$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse2$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse2ToJSON(
+  filterProjectEnvsContentHintProjectsResponse2:
+    FilterProjectEnvsContentHintProjectsResponse2,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse2$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse2,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse2FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse2,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse2' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody3Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2399,6 +2825,33 @@ export namespace FilterProjectEnvsContentHintProjectsResponse1$ {
   export type Outbound = FilterProjectEnvsContentHintProjectsResponse1$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjectsResponse1ToJSON(
+  filterProjectEnvsContentHintProjectsResponse1:
+    FilterProjectEnvsContentHintProjectsResponse1,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjectsResponse1$outboundSchema.parse(
+      filterProjectEnvsContentHintProjectsResponse1,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjectsResponse1FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsContentHintProjectsResponse1,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjectsResponse1$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse1' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsContentHint$inboundSchema:
   z.ZodType<
@@ -2481,6 +2934,33 @@ export namespace FilterProjectEnvsResponseBodyProjectsContentHint$ {
     FilterProjectEnvsResponseBodyProjectsContentHint$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyProjectsContentHintToJSON(
+  filterProjectEnvsResponseBodyProjectsContentHint:
+    FilterProjectEnvsResponseBodyProjectsContentHint,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyProjectsContentHint$outboundSchema.parse(
+      filterProjectEnvsResponseBodyProjectsContentHint,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyProjectsContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyProjectsContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyProjectsContentHint$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsResponseBodyProjectsContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type$inboundSchema:
   z.ZodNativeEnum<
@@ -2556,6 +3036,31 @@ export namespace FilterProjectEnvsResponseBodyProjectsInternalContentHint$ {
     FilterProjectEnvsResponseBodyProjectsInternalContentHint$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyProjectsInternalContentHintToJSON(
+  filterProjectEnvsResponseBodyProjectsInternalContentHint:
+    FilterProjectEnvsResponseBodyProjectsInternalContentHint,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyProjectsInternalContentHint$outboundSchema
+      .parse(filterProjectEnvsResponseBodyProjectsInternalContentHint),
+  );
+}
+
+export function filterProjectEnvsResponseBodyProjectsInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyProjectsInternalContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyProjectsInternalContentHint$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBodyProjectsInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBodyEnvs$inboundSchema: z.ZodType<
   ResponseBodyEnvs,
@@ -2768,6 +3273,24 @@ export namespace ResponseBodyEnvs$ {
   export type Outbound = ResponseBodyEnvs$Outbound;
 }
 
+export function responseBodyEnvsToJSON(
+  responseBodyEnvs: ResponseBodyEnvs,
+): string {
+  return JSON.stringify(
+    ResponseBodyEnvs$outboundSchema.parse(responseBodyEnvs),
+  );
+}
+
+export function responseBodyEnvsFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyEnvs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyEnvs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyEnvs' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBody3$inboundSchema: z.ZodType<
   FilterProjectEnvsResponseBody3,
@@ -2804,6 +3327,26 @@ export namespace FilterProjectEnvsResponseBody3$ {
   export type Outbound = FilterProjectEnvsResponseBody3$Outbound;
 }
 
+export function filterProjectEnvsResponseBody3ToJSON(
+  filterProjectEnvsResponseBody3: FilterProjectEnvsResponseBody3,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBody3$outboundSchema.parse(
+      filterProjectEnvsResponseBody3,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBody3FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsResponseBody3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsResponseBody3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBody3' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsTargetProjects2$inboundSchema: z.ZodNativeEnum<
   typeof FilterProjectEnvsTargetProjects2
@@ -2888,6 +3431,33 @@ export namespace FilterProjectEnvsResponseBodyProjectsTarget$ {
   export type Outbound = FilterProjectEnvsResponseBodyProjectsTarget$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyProjectsTargetToJSON(
+  filterProjectEnvsResponseBodyProjectsTarget:
+    FilterProjectEnvsResponseBodyProjectsTarget,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyProjectsTarget$outboundSchema.parse(
+      filterProjectEnvsResponseBodyProjectsTarget,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyProjectsTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyProjectsTarget,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyProjectsTarget$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsResponseBodyProjectsTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsResponseBodyProjectsResponseType> = z
@@ -2982,6 +3552,28 @@ export namespace FilterProjectEnvsContentHintProjects15$ {
   export type Outbound = FilterProjectEnvsContentHintProjects15$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects15ToJSON(
+  filterProjectEnvsContentHintProjects15:
+    FilterProjectEnvsContentHintProjects15,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects15$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects15,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects15FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects15' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs14Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3062,6 +3654,28 @@ export namespace FilterProjectEnvsContentHintProjects14$ {
   export type Outbound = FilterProjectEnvsContentHintProjects14$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects14ToJSON(
+  filterProjectEnvsContentHintProjects14:
+    FilterProjectEnvsContentHintProjects14,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects14$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects14,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects14FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects14' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs13Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3133,6 +3747,28 @@ export namespace FilterProjectEnvsContentHintProjects13$ {
   export type Outbound = FilterProjectEnvsContentHintProjects13$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects13ToJSON(
+  filterProjectEnvsContentHintProjects13:
+    FilterProjectEnvsContentHintProjects13,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects13$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects13,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects13FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects13' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs12Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3204,6 +3840,28 @@ export namespace FilterProjectEnvsContentHintProjects12$ {
   export type Outbound = FilterProjectEnvsContentHintProjects12$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects12ToJSON(
+  filterProjectEnvsContentHintProjects12:
+    FilterProjectEnvsContentHintProjects12,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects12$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects12,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects12FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects12' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs11Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3275,6 +3933,28 @@ export namespace FilterProjectEnvsContentHintProjects11$ {
   export type Outbound = FilterProjectEnvsContentHintProjects11$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects11ToJSON(
+  filterProjectEnvsContentHintProjects11:
+    FilterProjectEnvsContentHintProjects11,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects11$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects11,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects11FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects11' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs10Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3346,6 +4026,28 @@ export namespace FilterProjectEnvsContentHintProjects10$ {
   export type Outbound = FilterProjectEnvsContentHintProjects10$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects10ToJSON(
+  filterProjectEnvsContentHintProjects10:
+    FilterProjectEnvsContentHintProjects10,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects10$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects10,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects10FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects10' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs9Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3417,6 +4119,27 @@ export namespace FilterProjectEnvsContentHintProjects9$ {
   export type Outbound = FilterProjectEnvsContentHintProjects9$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects9ToJSON(
+  filterProjectEnvsContentHintProjects9: FilterProjectEnvsContentHintProjects9,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects9$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects9,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects9FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects9' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs8Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3488,6 +4211,27 @@ export namespace FilterProjectEnvsContentHintProjects8$ {
   export type Outbound = FilterProjectEnvsContentHintProjects8$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects8ToJSON(
+  filterProjectEnvsContentHintProjects8: FilterProjectEnvsContentHintProjects8,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects8$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects8,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects8FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects8' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs7Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3559,6 +4303,27 @@ export namespace FilterProjectEnvsContentHintProjects7$ {
   export type Outbound = FilterProjectEnvsContentHintProjects7$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects7ToJSON(
+  filterProjectEnvsContentHintProjects7: FilterProjectEnvsContentHintProjects7,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects7$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects7,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects7FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects7' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs6Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3630,6 +4395,27 @@ export namespace FilterProjectEnvsContentHintProjects6$ {
   export type Outbound = FilterProjectEnvsContentHintProjects6$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects6ToJSON(
+  filterProjectEnvsContentHintProjects6: FilterProjectEnvsContentHintProjects6,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects6$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects6,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects6FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects6' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs5Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3701,6 +4487,27 @@ export namespace FilterProjectEnvsContentHintProjects5$ {
   export type Outbound = FilterProjectEnvsContentHintProjects5$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects5ToJSON(
+  filterProjectEnvsContentHintProjects5: FilterProjectEnvsContentHintProjects5,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects5$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects5,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects5FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects5' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs4Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3772,6 +4579,27 @@ export namespace FilterProjectEnvsContentHintProjects4$ {
   export type Outbound = FilterProjectEnvsContentHintProjects4$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects4ToJSON(
+  filterProjectEnvsContentHintProjects4: FilterProjectEnvsContentHintProjects4,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects4$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects4,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects4FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects4' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Envs3Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3843,6 +4671,27 @@ export namespace FilterProjectEnvsContentHintProjects3$ {
   export type Outbound = FilterProjectEnvsContentHintProjects3$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects3ToJSON(
+  filterProjectEnvsContentHintProjects3: FilterProjectEnvsContentHintProjects3,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects3$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects3,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects3FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects3' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2EnvsType$inboundSchema:
   z.ZodNativeEnum<
@@ -3914,6 +4763,27 @@ export namespace FilterProjectEnvsContentHintProjects2$ {
   export type Outbound = FilterProjectEnvsContentHintProjects2$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects2ToJSON(
+  filterProjectEnvsContentHintProjects2: FilterProjectEnvsContentHintProjects2,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects2$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects2,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects2FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects2' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody2Type$inboundSchema:
   z.ZodNativeEnum<
@@ -3985,6 +4855,27 @@ export namespace FilterProjectEnvsContentHintProjects1$ {
   export type Outbound = FilterProjectEnvsContentHintProjects1$Outbound;
 }
 
+export function filterProjectEnvsContentHintProjects1ToJSON(
+  filterProjectEnvsContentHintProjects1: FilterProjectEnvsContentHintProjects1,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHintProjects1$outboundSchema.parse(
+      filterProjectEnvsContentHintProjects1,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHintProjects1FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHintProjects1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsContentHintProjects1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHintProjects1' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyContentHint$inboundSchema: z.ZodType<
   FilterProjectEnvsResponseBodyContentHint,
@@ -4064,6 +4955,33 @@ export namespace FilterProjectEnvsResponseBodyContentHint$ {
   export type Outbound = FilterProjectEnvsResponseBodyContentHint$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyContentHintToJSON(
+  filterProjectEnvsResponseBodyContentHint:
+    FilterProjectEnvsResponseBodyContentHint,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyContentHint$outboundSchema.parse(
+      filterProjectEnvsResponseBodyContentHint,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyContentHint$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsResponseBodyContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -4138,6 +5056,33 @@ export namespace FilterProjectEnvsResponseBodyInternalContentHint$ {
     FilterProjectEnvsResponseBodyInternalContentHint$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyInternalContentHintToJSON(
+  filterProjectEnvsResponseBodyInternalContentHint:
+    FilterProjectEnvsResponseBodyInternalContentHint,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyInternalContentHint$outboundSchema.parse(
+      filterProjectEnvsResponseBodyInternalContentHint,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  FilterProjectEnvsResponseBodyInternalContentHint,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyInternalContentHint$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'FilterProjectEnvsResponseBodyInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const Envs$inboundSchema: z.ZodType<Envs, z.ZodTypeDef, unknown> = z
   .object({
@@ -4300,6 +5245,20 @@ export namespace Envs$ {
   export type Outbound = Envs$Outbound;
 }
 
+export function envsToJSON(envs: Envs): string {
+  return JSON.stringify(Envs$outboundSchema.parse(envs));
+}
+
+export function envsFromJSON(
+  jsonString: string,
+): SafeParseResult<Envs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Envs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Envs' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBody2$inboundSchema: z.ZodType<
   FilterProjectEnvsResponseBody2,
@@ -4339,6 +5298,26 @@ export namespace FilterProjectEnvsResponseBody2$ {
   export type Outbound = FilterProjectEnvsResponseBody2$Outbound;
 }
 
+export function filterProjectEnvsResponseBody2ToJSON(
+  filterProjectEnvsResponseBody2: FilterProjectEnvsResponseBody2,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBody2$outboundSchema.parse(
+      filterProjectEnvsResponseBody2,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsTarget2$inboundSchema: z.ZodNativeEnum<
   typeof FilterProjectEnvsTarget2
@@ -4394,6 +5373,27 @@ export namespace FilterProjectEnvsResponseBodyTarget$ {
   export type Outbound = FilterProjectEnvsResponseBodyTarget$Outbound;
 }
 
+export function filterProjectEnvsResponseBodyTargetToJSON(
+  filterProjectEnvsResponseBodyTarget: FilterProjectEnvsResponseBodyTarget,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBodyTarget$outboundSchema.parse(
+      filterProjectEnvsResponseBodyTarget,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsResponseBodyTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FilterProjectEnvsResponseBodyTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBodyTarget' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyType$inboundSchema: z.ZodNativeEnum<
   typeof FilterProjectEnvsResponseBodyType
@@ -4485,6 +5485,26 @@ export namespace FilterProjectEnvsContentHint15$ {
   export type Outbound = FilterProjectEnvsContentHint15$Outbound;
 }
 
+export function filterProjectEnvsContentHint15ToJSON(
+  filterProjectEnvsContentHint15: FilterProjectEnvsContentHint15,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint15$outboundSchema.parse(
+      filterProjectEnvsContentHint15,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint15FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint15, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint15$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint15' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody114Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4563,6 +5583,26 @@ export namespace FilterProjectEnvsContentHint14$ {
   export type Outbound = FilterProjectEnvsContentHint14$Outbound;
 }
 
+export function filterProjectEnvsContentHint14ToJSON(
+  filterProjectEnvsContentHint14: FilterProjectEnvsContentHint14,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint14$outboundSchema.parse(
+      filterProjectEnvsContentHint14,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint14FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint14, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint14$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint14' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody113Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4632,6 +5672,26 @@ export namespace FilterProjectEnvsContentHint13$ {
   export type Outbound = FilterProjectEnvsContentHint13$Outbound;
 }
 
+export function filterProjectEnvsContentHint13ToJSON(
+  filterProjectEnvsContentHint13: FilterProjectEnvsContentHint13,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint13$outboundSchema.parse(
+      filterProjectEnvsContentHint13,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint13FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint13, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint13$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint13' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody112Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4701,6 +5761,26 @@ export namespace FilterProjectEnvsContentHint12$ {
   export type Outbound = FilterProjectEnvsContentHint12$Outbound;
 }
 
+export function filterProjectEnvsContentHint12ToJSON(
+  filterProjectEnvsContentHint12: FilterProjectEnvsContentHint12,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint12$outboundSchema.parse(
+      filterProjectEnvsContentHint12,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint12FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint12, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint12$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint12' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody111Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4770,6 +5850,26 @@ export namespace FilterProjectEnvsContentHint11$ {
   export type Outbound = FilterProjectEnvsContentHint11$Outbound;
 }
 
+export function filterProjectEnvsContentHint11ToJSON(
+  filterProjectEnvsContentHint11: FilterProjectEnvsContentHint11,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint11$outboundSchema.parse(
+      filterProjectEnvsContentHint11,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint11FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint11, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint11$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint11' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody110Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4839,6 +5939,26 @@ export namespace FilterProjectEnvsContentHint10$ {
   export type Outbound = FilterProjectEnvsContentHint10$Outbound;
 }
 
+export function filterProjectEnvsContentHint10ToJSON(
+  filterProjectEnvsContentHint10: FilterProjectEnvsContentHint10,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint10$outboundSchema.parse(
+      filterProjectEnvsContentHint10,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint10FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint10, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint10$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint10' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody19Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4908,6 +6028,26 @@ export namespace FilterProjectEnvsContentHint9$ {
   export type Outbound = FilterProjectEnvsContentHint9$Outbound;
 }
 
+export function filterProjectEnvsContentHint9ToJSON(
+  filterProjectEnvsContentHint9: FilterProjectEnvsContentHint9,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint9$outboundSchema.parse(
+      filterProjectEnvsContentHint9,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint9FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint9, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint9$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint9' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody18Type$inboundSchema:
   z.ZodNativeEnum<
@@ -4977,6 +6117,26 @@ export namespace FilterProjectEnvsContentHint8$ {
   export type Outbound = FilterProjectEnvsContentHint8$Outbound;
 }
 
+export function filterProjectEnvsContentHint8ToJSON(
+  filterProjectEnvsContentHint8: FilterProjectEnvsContentHint8,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint8$outboundSchema.parse(
+      filterProjectEnvsContentHint8,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint8FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint8, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint8$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint8' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBody1Type$inboundSchema:
   z.ZodNativeEnum<
@@ -5046,6 +6206,26 @@ export namespace FilterProjectEnvsContentHint7$ {
   export type Outbound = FilterProjectEnvsContentHint7$Outbound;
 }
 
+export function filterProjectEnvsContentHint7ToJSON(
+  filterProjectEnvsContentHint7: FilterProjectEnvsContentHint7,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint7$outboundSchema.parse(
+      filterProjectEnvsContentHint7,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint7FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint7, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint7$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint7' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema:
   z.ZodNativeEnum<
@@ -5115,6 +6295,26 @@ export namespace FilterProjectEnvsContentHint6$ {
   export type Outbound = FilterProjectEnvsContentHint6$Outbound;
 }
 
+export function filterProjectEnvsContentHint6ToJSON(
+  filterProjectEnvsContentHint6: FilterProjectEnvsContentHint6,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint6$outboundSchema.parse(
+      filterProjectEnvsContentHint6,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint6FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint6' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200ApplicationJSONType$inboundSchema:
   z.ZodNativeEnum<
@@ -5184,6 +6384,26 @@ export namespace FilterProjectEnvsContentHint5$ {
   export type Outbound = FilterProjectEnvsContentHint5$Outbound;
 }
 
+export function filterProjectEnvsContentHint5ToJSON(
+  filterProjectEnvsContentHint5: FilterProjectEnvsContentHint5,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint5$outboundSchema.parse(
+      filterProjectEnvsContentHint5,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint5FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint5' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsContentHintProjectsResponse200Type> =
@@ -5246,6 +6466,26 @@ export namespace FilterProjectEnvsContentHint4$ {
   export type Outbound = FilterProjectEnvsContentHint4$Outbound;
 }
 
+export function filterProjectEnvsContentHint4ToJSON(
+  filterProjectEnvsContentHint4: FilterProjectEnvsContentHint4,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint4$outboundSchema.parse(
+      filterProjectEnvsContentHint4,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint4FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint4' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsResponseType$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsContentHintProjectsResponseType> = z
@@ -5308,6 +6548,26 @@ export namespace FilterProjectEnvsContentHint3$ {
   export type Outbound = FilterProjectEnvsContentHint3$Outbound;
 }
 
+export function filterProjectEnvsContentHint3ToJSON(
+  filterProjectEnvsContentHint3: FilterProjectEnvsContentHint3,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint3$outboundSchema.parse(
+      filterProjectEnvsContentHint3,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint3FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint3' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsContentHintProjectsType> = z
@@ -5370,6 +6630,26 @@ export namespace FilterProjectEnvsContentHint2$ {
   export type Outbound = FilterProjectEnvsContentHint2$Outbound;
 }
 
+export function filterProjectEnvsContentHint2ToJSON(
+  filterProjectEnvsContentHint2: FilterProjectEnvsContentHint2,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint2$outboundSchema.parse(
+      filterProjectEnvsContentHint2,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint2FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint2' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsContentHintType$inboundSchema: z.ZodNativeEnum<
   typeof FilterProjectEnvsContentHintType
@@ -5430,6 +6710,26 @@ export namespace FilterProjectEnvsContentHint1$ {
   export type Outbound = FilterProjectEnvsContentHint1$Outbound;
 }
 
+export function filterProjectEnvsContentHint1ToJSON(
+  filterProjectEnvsContentHint1: FilterProjectEnvsContentHint1,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsContentHint1$outboundSchema.parse(
+      filterProjectEnvsContentHint1,
+    ),
+  );
+}
+
+export function filterProjectEnvsContentHint1FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsContentHint1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsContentHint1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsContentHint1' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBodyContentHint$inboundSchema: z.ZodType<
   ResponseBodyContentHint,
@@ -5507,6 +6807,24 @@ export namespace ResponseBodyContentHint$ {
   export type Outbound = ResponseBodyContentHint$Outbound;
 }
 
+export function responseBodyContentHintToJSON(
+  responseBodyContentHint: ResponseBodyContentHint,
+): string {
+  return JSON.stringify(
+    ResponseBodyContentHint$outboundSchema.parse(responseBodyContentHint),
+  );
+}
+
+export function responseBodyContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBodyProjectsType$inboundSchema:
   z.ZodNativeEnum<typeof FilterProjectEnvsResponseBodyProjectsType> = z
@@ -5569,6 +6887,26 @@ export namespace ResponseBodyInternalContentHint$ {
   export type Outbound = ResponseBodyInternalContentHint$Outbound;
 }
 
+export function responseBodyInternalContentHintToJSON(
+  responseBodyInternalContentHint: ResponseBodyInternalContentHint,
+): string {
+  return JSON.stringify(
+    ResponseBodyInternalContentHint$outboundSchema.parse(
+      responseBodyInternalContentHint,
+    ),
+  );
+}
+
+export function responseBodyInternalContentHintFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyInternalContentHint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyInternalContentHint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyInternalContentHint' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBody1$inboundSchema: z.ZodType<
   FilterProjectEnvsResponseBody1,
@@ -5729,6 +7067,26 @@ export namespace FilterProjectEnvsResponseBody1$ {
   export type Outbound = FilterProjectEnvsResponseBody1$Outbound;
 }
 
+export function filterProjectEnvsResponseBody1ToJSON(
+  filterProjectEnvsResponseBody1: FilterProjectEnvsResponseBody1,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBody1$outboundSchema.parse(
+      filterProjectEnvsResponseBody1,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const FilterProjectEnvsResponseBody$inboundSchema: z.ZodType<
   FilterProjectEnvsResponseBody,
@@ -5769,3 +7127,23 @@ export namespace FilterProjectEnvsResponseBody$ {
   /** @deprecated use `FilterProjectEnvsResponseBody$Outbound` instead. */
   export type Outbound = FilterProjectEnvsResponseBody$Outbound;
 }
+
+export function filterProjectEnvsResponseBodyToJSON(
+  filterProjectEnvsResponseBody: FilterProjectEnvsResponseBody,
+): string {
+  return JSON.stringify(
+    FilterProjectEnvsResponseBody$outboundSchema.parse(
+      filterProjectEnvsResponseBody,
+    ),
+  );
+}
+
+export function filterProjectEnvsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<FilterProjectEnvsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilterProjectEnvsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilterProjectEnvsResponseBody' from JSON`,
+  );
+}