/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
import { Pagination, Pagination$inboundSchema } from "./pagination.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

/**
 * If true, the environment variable value will be decrypted
 *
 * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
 */
export const Decrypt = {
  True: "true",
  False: "false",
} as const;
/**
 * If true, the environment variable value will be decrypted
 *
 * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
 */
export type Decrypt = ClosedEnum<typeof Decrypt>;

export type FilterProjectEnvsRequest = {
  /**
   * The unique project identifier or the project name
   */
  idOrName: string;
  /**
   * If defined, the git branch of the environment variable to filter the results (must have target=preview)
   */
  gitBranch?: string | undefined;
  /**
   * If true, the environment variable value will be decrypted
   */
  decrypt?: Decrypt | undefined;
  /**
   * The source that is calling the endpoint.
   */
  source?: string | undefined;
  /**
   * The unique custom environment identifier within the project
   */
  customEnvironmentId?: string | undefined;
  /**
   * The custom environment slug (name) within the project
   */
  customEnvironmentSlug?: string | undefined;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
};

export const FilterProjectEnvsTargetProjectsResponse2 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTargetProjectsResponse2 = ClosedEnum<
  typeof FilterProjectEnvsTargetProjectsResponse2
>;

export const FilterProjectEnvsTargetProjectsResponse1 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTargetProjectsResponse1 = ClosedEnum<
  typeof FilterProjectEnvsTargetProjectsResponse1
>;

export type FilterProjectEnvsResponseBodyProjectsResponseTarget =
  | Array<FilterProjectEnvsTargetProjectsResponse1>
  | FilterProjectEnvsTargetProjectsResponse2;

export const FilterProjectEnvsResponseBodyProjectsResponse200Type = {
  Encrypted: "encrypted",
  Plain: "plain",
  Secret: "secret",
  Sensitive: "sensitive",
  System: "system",
} as const;
export type FilterProjectEnvsResponseBodyProjectsResponse200Type = ClosedEnum<
  typeof FilterProjectEnvsResponseBodyProjectsResponse200Type
>;

export type FilterProjectEnvsContentHintProjectsResponse17 = {
  type: "flags-connection-string";
  projectId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse16 = {
  type: "integration-store-secret";
  storeId: string;
  integrationId: string;
  integrationProductId: string;
  integrationConfigurationId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse15 = {
  type: "postgres-url-no-ssl";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse14 = {
  type: "postgres-database";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse13 = {
  type: "postgres-password";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse12 = {
  type: "postgres-host";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse11 = {
  type: "postgres-user";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse10 = {
  type: "postgres-prisma-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse9 = {
  type: "postgres-url-non-pooling";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse8 = {
  type: "postgres-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse7 = {
  type: "blob-webhook-public-key";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse6 = {
  type: "blob-store-id";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse5 = {
  type: "blob-read-write-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse4 = {
  type: "redis-rest-api-read-only-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse3 = {
  type: "redis-rest-api-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse2 = {
  type: "redis-rest-api-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjectsResponse1 = {
  type: "redis-url";
  storeId: string;
};

export type FilterProjectEnvsResponseBodyProjectsContentHint =
  | FilterProjectEnvsContentHintProjectsResponse1
  | FilterProjectEnvsContentHintProjectsResponse2
  | FilterProjectEnvsContentHintProjectsResponse3
  | FilterProjectEnvsContentHintProjectsResponse4
  | FilterProjectEnvsContentHintProjectsResponse5
  | FilterProjectEnvsContentHintProjectsResponse6
  | FilterProjectEnvsContentHintProjectsResponse7
  | FilterProjectEnvsContentHintProjectsResponse8
  | FilterProjectEnvsContentHintProjectsResponse9
  | FilterProjectEnvsContentHintProjectsResponse10
  | FilterProjectEnvsContentHintProjectsResponse11
  | FilterProjectEnvsContentHintProjectsResponse12
  | FilterProjectEnvsContentHintProjectsResponse13
  | FilterProjectEnvsContentHintProjectsResponse14
  | FilterProjectEnvsContentHintProjectsResponse15
  | FilterProjectEnvsContentHintProjectsResponse16
  | FilterProjectEnvsContentHintProjectsResponse17;

export const FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type =
  {
    FlagsSecret: "flags-secret",
  } as const;
export type FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type =
  ClosedEnum<
    typeof FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type
  >;

/**
 * Similar to `contentHints`, but should not be exposed to the user.
 */
export type FilterProjectEnvsResponseBodyProjectsInternalContentHint = {
  type: FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type;
  /**
   * Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
   */
  encryptedValue: string;
};

export type ResponseBodyEnvs = {
  target?:
    | Array<FilterProjectEnvsTargetProjectsResponse1>
    | FilterProjectEnvsTargetProjectsResponse2
    | undefined;
  type: FilterProjectEnvsResponseBodyProjectsResponse200Type;
  /**
   * This is used to identify variables that have been migrated from type secret to sensitive.
   */
  sunsetSecretId?: string | undefined;
  /**
   * Legacy now-encryption ciphertext, present after migration swaps value/vsmValue
   */
  legacyValue?: string | undefined;
  decrypted?: boolean | undefined;
  value: string;
  vsmValue?: string | undefined;
  id?: string | undefined;
  key: string;
  configurationId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  gitBranch?: string | undefined;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  contentHint?:
    | FilterProjectEnvsContentHintProjectsResponse1
    | FilterProjectEnvsContentHintProjectsResponse2
    | FilterProjectEnvsContentHintProjectsResponse3
    | FilterProjectEnvsContentHintProjectsResponse4
    | FilterProjectEnvsContentHintProjectsResponse5
    | FilterProjectEnvsContentHintProjectsResponse6
    | FilterProjectEnvsContentHintProjectsResponse7
    | FilterProjectEnvsContentHintProjectsResponse8
    | FilterProjectEnvsContentHintProjectsResponse9
    | FilterProjectEnvsContentHintProjectsResponse10
    | FilterProjectEnvsContentHintProjectsResponse11
    | FilterProjectEnvsContentHintProjectsResponse12
    | FilterProjectEnvsContentHintProjectsResponse13
    | FilterProjectEnvsContentHintProjectsResponse14
    | FilterProjectEnvsContentHintProjectsResponse15
    | FilterProjectEnvsContentHintProjectsResponse16
    | FilterProjectEnvsContentHintProjectsResponse17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | FilterProjectEnvsResponseBodyProjectsInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
  system?: boolean | undefined;
};

/**
 * The list of environment variables for the given project
 */
export type FilterProjectEnvsResponseBody3 = {
  envs: Array<ResponseBodyEnvs>;
  hiddenProductionEnvCount: number;
};

export const FilterProjectEnvsTargetProjects2 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTargetProjects2 = ClosedEnum<
  typeof FilterProjectEnvsTargetProjects2
>;

export const FilterProjectEnvsTargetProjects1 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTargetProjects1 = ClosedEnum<
  typeof FilterProjectEnvsTargetProjects1
>;

export type FilterProjectEnvsResponseBodyProjectsTarget =
  | Array<FilterProjectEnvsTargetProjects1>
  | FilterProjectEnvsTargetProjects2;

export const FilterProjectEnvsResponseBodyProjectsResponseType = {
  Encrypted: "encrypted",
  Plain: "plain",
  Secret: "secret",
  Sensitive: "sensitive",
  System: "system",
} as const;
export type FilterProjectEnvsResponseBodyProjectsResponseType = ClosedEnum<
  typeof FilterProjectEnvsResponseBodyProjectsResponseType
>;

export type FilterProjectEnvsContentHintProjects17 = {
  type: "flags-connection-string";
  projectId: string;
};

export type FilterProjectEnvsContentHintProjects16 = {
  type: "integration-store-secret";
  storeId: string;
  integrationId: string;
  integrationProductId: string;
  integrationConfigurationId: string;
};

export type FilterProjectEnvsContentHintProjects15 = {
  type: "postgres-url-no-ssl";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects14 = {
  type: "postgres-database";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects13 = {
  type: "postgres-password";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects12 = {
  type: "postgres-host";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects11 = {
  type: "postgres-user";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects10 = {
  type: "postgres-prisma-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects9 = {
  type: "postgres-url-non-pooling";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects8 = {
  type: "postgres-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects7 = {
  type: "blob-webhook-public-key";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects6 = {
  type: "blob-store-id";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects5 = {
  type: "blob-read-write-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects4 = {
  type: "redis-rest-api-read-only-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects3 = {
  type: "redis-rest-api-token";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects2 = {
  type: "redis-rest-api-url";
  storeId: string;
};

export type FilterProjectEnvsContentHintProjects1 = {
  type: "redis-url";
  storeId: string;
};

export type FilterProjectEnvsResponseBodyContentHint =
  | FilterProjectEnvsContentHintProjects1
  | FilterProjectEnvsContentHintProjects2
  | FilterProjectEnvsContentHintProjects3
  | FilterProjectEnvsContentHintProjects4
  | FilterProjectEnvsContentHintProjects5
  | FilterProjectEnvsContentHintProjects6
  | FilterProjectEnvsContentHintProjects7
  | FilterProjectEnvsContentHintProjects8
  | FilterProjectEnvsContentHintProjects9
  | FilterProjectEnvsContentHintProjects10
  | FilterProjectEnvsContentHintProjects11
  | FilterProjectEnvsContentHintProjects12
  | FilterProjectEnvsContentHintProjects13
  | FilterProjectEnvsContentHintProjects14
  | FilterProjectEnvsContentHintProjects15
  | FilterProjectEnvsContentHintProjects16
  | FilterProjectEnvsContentHintProjects17;

export const FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType =
  {
    FlagsSecret: "flags-secret",
  } as const;
export type FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType =
  ClosedEnum<
    typeof FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType
  >;

/**
 * Similar to `contentHints`, but should not be exposed to the user.
 */
export type FilterProjectEnvsResponseBodyInternalContentHint = {
  type: FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType;
  /**
   * Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
   */
  encryptedValue: string;
};

export type Envs = {
  target?:
    | Array<FilterProjectEnvsTargetProjects1>
    | FilterProjectEnvsTargetProjects2
    | undefined;
  type: FilterProjectEnvsResponseBodyProjectsResponseType;
  /**
   * This is used to identify variables that have been migrated from type secret to sensitive.
   */
  sunsetSecretId?: string | undefined;
  /**
   * Legacy now-encryption ciphertext, present after migration swaps value/vsmValue
   */
  legacyValue?: string | undefined;
  decrypted?: boolean | undefined;
  value: string;
  vsmValue?: string | undefined;
  id?: string | undefined;
  key: string;
  configurationId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  gitBranch?: string | undefined;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  contentHint?:
    | FilterProjectEnvsContentHintProjects1
    | FilterProjectEnvsContentHintProjects2
    | FilterProjectEnvsContentHintProjects3
    | FilterProjectEnvsContentHintProjects4
    | FilterProjectEnvsContentHintProjects5
    | FilterProjectEnvsContentHintProjects6
    | FilterProjectEnvsContentHintProjects7
    | FilterProjectEnvsContentHintProjects8
    | FilterProjectEnvsContentHintProjects9
    | FilterProjectEnvsContentHintProjects10
    | FilterProjectEnvsContentHintProjects11
    | FilterProjectEnvsContentHintProjects12
    | FilterProjectEnvsContentHintProjects13
    | FilterProjectEnvsContentHintProjects14
    | FilterProjectEnvsContentHintProjects15
    | FilterProjectEnvsContentHintProjects16
    | FilterProjectEnvsContentHintProjects17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | FilterProjectEnvsResponseBodyInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
  system?: boolean | undefined;
};

export type FilterProjectEnvsResponseBody2 = {
  envs: Array<Envs>;
  /**
   * This object contains information related to the pagination of the current request, including the necessary parameters to get the next or previous page of data.
   */
  pagination: Pagination;
};

export const FilterProjectEnvsTarget2 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTarget2 = ClosedEnum<
  typeof FilterProjectEnvsTarget2
>;

export const FilterProjectEnvsTarget1 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type FilterProjectEnvsTarget1 = ClosedEnum<
  typeof FilterProjectEnvsTarget1
>;

export type FilterProjectEnvsResponseBodyTarget =
  | Array<FilterProjectEnvsTarget1>
  | FilterProjectEnvsTarget2;

export const FilterProjectEnvsResponseBodyType = {
  Encrypted: "encrypted",
  Plain: "plain",
  Secret: "secret",
  Sensitive: "sensitive",
  System: "system",
} as const;
export type FilterProjectEnvsResponseBodyType = ClosedEnum<
  typeof FilterProjectEnvsResponseBodyType
>;

export type FilterProjectEnvsContentHint17 = {
  type: "flags-connection-string";
  projectId: string;
};

export type FilterProjectEnvsContentHint16 = {
  type: "integration-store-secret";
  storeId: string;
  integrationId: string;
  integrationProductId: string;
  integrationConfigurationId: string;
};

export type FilterProjectEnvsContentHint15 = {
  type: "postgres-url-no-ssl";
  storeId: string;
};

export type FilterProjectEnvsContentHint14 = {
  type: "postgres-database";
  storeId: string;
};

export type FilterProjectEnvsContentHint13 = {
  type: "postgres-password";
  storeId: string;
};

export type FilterProjectEnvsContentHint12 = {
  type: "postgres-host";
  storeId: string;
};

export type FilterProjectEnvsContentHint11 = {
  type: "postgres-user";
  storeId: string;
};

export type FilterProjectEnvsContentHint10 = {
  type: "postgres-prisma-url";
  storeId: string;
};

export type FilterProjectEnvsContentHint9 = {
  type: "postgres-url-non-pooling";
  storeId: string;
};

export type FilterProjectEnvsContentHint8 = {
  type: "postgres-url";
  storeId: string;
};

export type FilterProjectEnvsContentHint7 = {
  type: "blob-webhook-public-key";
  storeId: string;
};

export type FilterProjectEnvsContentHint6 = {
  type: "blob-store-id";
  storeId: string;
};

export type FilterProjectEnvsContentHint5 = {
  type: "blob-read-write-token";
  storeId: string;
};

export type FilterProjectEnvsContentHint4 = {
  type: "redis-rest-api-read-only-token";
  storeId: string;
};

export type FilterProjectEnvsContentHint3 = {
  type: "redis-rest-api-token";
  storeId: string;
};

export type FilterProjectEnvsContentHint2 = {
  type: "redis-rest-api-url";
  storeId: string;
};

export type FilterProjectEnvsContentHint1 = {
  type: "redis-url";
  storeId: string;
};

export type ResponseBodyContentHint =
  | FilterProjectEnvsContentHint1
  | FilterProjectEnvsContentHint2
  | FilterProjectEnvsContentHint3
  | FilterProjectEnvsContentHint4
  | FilterProjectEnvsContentHint5
  | FilterProjectEnvsContentHint6
  | FilterProjectEnvsContentHint7
  | FilterProjectEnvsContentHint8
  | FilterProjectEnvsContentHint9
  | FilterProjectEnvsContentHint10
  | FilterProjectEnvsContentHint11
  | FilterProjectEnvsContentHint12
  | FilterProjectEnvsContentHint13
  | FilterProjectEnvsContentHint14
  | FilterProjectEnvsContentHint15
  | FilterProjectEnvsContentHint16
  | FilterProjectEnvsContentHint17;

export const FilterProjectEnvsResponseBodyProjectsType = {
  FlagsSecret: "flags-secret",
} as const;
export type FilterProjectEnvsResponseBodyProjectsType = ClosedEnum<
  typeof FilterProjectEnvsResponseBodyProjectsType
>;

/**
 * Similar to `contentHints`, but should not be exposed to the user.
 */
export type ResponseBodyInternalContentHint = {
  type: FilterProjectEnvsResponseBodyProjectsType;
  /**
   * Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
   */
  encryptedValue: string;
};

export type FilterProjectEnvsResponseBody1 = {
  target?:
    | Array<FilterProjectEnvsTarget1>
    | FilterProjectEnvsTarget2
    | undefined;
  type: FilterProjectEnvsResponseBodyType;
  /**
   * This is used to identify variables that have been migrated from type secret to sensitive.
   */
  sunsetSecretId?: string | undefined;
  /**
   * Legacy now-encryption ciphertext, present after migration swaps value/vsmValue
   */
  legacyValue?: string | undefined;
  decrypted?: boolean | undefined;
  value: string;
  vsmValue?: string | undefined;
  id?: string | undefined;
  key: string;
  configurationId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  gitBranch?: string | undefined;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  contentHint?:
    | FilterProjectEnvsContentHint1
    | FilterProjectEnvsContentHint2
    | FilterProjectEnvsContentHint3
    | FilterProjectEnvsContentHint4
    | FilterProjectEnvsContentHint5
    | FilterProjectEnvsContentHint6
    | FilterProjectEnvsContentHint7
    | FilterProjectEnvsContentHint8
    | FilterProjectEnvsContentHint9
    | FilterProjectEnvsContentHint10
    | FilterProjectEnvsContentHint11
    | FilterProjectEnvsContentHint12
    | FilterProjectEnvsContentHint13
    | FilterProjectEnvsContentHint14
    | FilterProjectEnvsContentHint15
    | FilterProjectEnvsContentHint16
    | FilterProjectEnvsContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?: ResponseBodyInternalContentHint | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
  system?: boolean | undefined;
};

/**
 * The list of environment variables for the given project
 */
export type FilterProjectEnvsResponseBody =
  | FilterProjectEnvsResponseBody1
  | FilterProjectEnvsResponseBody2
  | FilterProjectEnvsResponseBody3;

/** @internal */
export const Decrypt$outboundSchema: z.ZodNativeEnum<typeof Decrypt> = z
  .nativeEnum(Decrypt);

/** @internal */
export type FilterProjectEnvsRequest$Outbound = {
  idOrName: string;
  gitBranch?: string | undefined;
  decrypt?: string | undefined;
  source?: string | undefined;
  customEnvironmentId?: string | undefined;
  customEnvironmentSlug?: string | undefined;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const FilterProjectEnvsRequest$outboundSchema: z.ZodType<
  FilterProjectEnvsRequest$Outbound,
  z.ZodTypeDef,
  FilterProjectEnvsRequest
> = z.object({
  idOrName: z.string(),
  gitBranch: z.string().optional(),
  decrypt: Decrypt$outboundSchema.optional(),
  source: z.string().optional(),
  customEnvironmentId: z.string().optional(),
  customEnvironmentSlug: z.string().optional(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function filterProjectEnvsRequestToJSON(
  filterProjectEnvsRequest: FilterProjectEnvsRequest,
): string {
  return JSON.stringify(
    FilterProjectEnvsRequest$outboundSchema.parse(filterProjectEnvsRequest),
  );
}

/** @internal */
export const FilterProjectEnvsTargetProjectsResponse2$inboundSchema:
  z.ZodNativeEnum<typeof FilterProjectEnvsTargetProjectsResponse2> = z
    .nativeEnum(FilterProjectEnvsTargetProjectsResponse2);

/** @internal */
export const FilterProjectEnvsTargetProjectsResponse1$inboundSchema:
  z.ZodNativeEnum<typeof FilterProjectEnvsTargetProjectsResponse1> = z
    .nativeEnum(FilterProjectEnvsTargetProjectsResponse1);

/** @internal */
export const FilterProjectEnvsResponseBodyProjectsResponseTarget$inboundSchema:
  z.ZodType<
    FilterProjectEnvsResponseBodyProjectsResponseTarget,
    z.ZodTypeDef,
    unknown
  > = smartUnion([
    z.array(FilterProjectEnvsTargetProjectsResponse1$inboundSchema),
    FilterProjectEnvsTargetProjectsResponse2$inboundSchema,
  ]);

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> =
    z.nativeEnum(FilterProjectEnvsResponseBodyProjectsResponse200Type);

/** @internal */
export const FilterProjectEnvsContentHintProjectsResponse17$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse17,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("flags-connection-string"),
    projectId: types.string(),
  });

export function filterProjectEnvsContentHintProjectsResponse17FromJSON(
  jsonString: string,
): SafeParseResult<
  FilterProjectEnvsContentHintProjectsResponse17,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      FilterProjectEnvsContentHintProjectsResponse17$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse17' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHintProjectsResponse16$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse16,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("integration-store-secret"),
    storeId: types.string(),
    integrationId: types.string(),
    integrationProductId: types.string(),
    integrationConfigurationId: types.string(),
  });

export function filterProjectEnvsContentHintProjectsResponse16FromJSON(
  jsonString: string,
): SafeParseResult<
  FilterProjectEnvsContentHintProjectsResponse16,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      FilterProjectEnvsContentHintProjectsResponse16$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'FilterProjectEnvsContentHintProjectsResponse16' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHintProjectsResponse15$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse15,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-url-no-ssl"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse14$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse14,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-database"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse13$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse13,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-password"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse12$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse12,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-host"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse11$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse11,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-user"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse10$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse10,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-prisma-url"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse9$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse9,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-url-non-pooling"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse8$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse8,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("postgres-url"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse7$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse7,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-webhook-public-key"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse6$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse6,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-store-id"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse5$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse5,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-read-write-token"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse4$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse4,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-rest-api-read-only-token"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse3$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse3,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-rest-api-token"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse2$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse2,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-rest-api-url"),
    storeId: types.string(),
  });

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 FilterProjectEnvsContentHintProjectsResponse1$inboundSchema:
  z.ZodType<
    FilterProjectEnvsContentHintProjectsResponse1,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-url"),
    storeId: types.string(),
  });

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<
    FilterProjectEnvsResponseBodyProjectsContentHint,
    z.ZodTypeDef,
    unknown
  > = z.union([
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse1$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse2$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse3$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse4$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse5$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse6$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse7$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse8$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse9$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse10$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse11$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse12$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse13$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse14$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse15$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse16$inboundSchema),
    z.lazy(() => FilterProjectEnvsContentHintProjectsResponse17$inboundSchema),
  ]);

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<
    typeof FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type
  > = z.nativeEnum(
    FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type,
  );

/** @internal */
export const FilterProjectEnvsResponseBodyProjectsInternalContentHint$inboundSchema:
  z.ZodType<
    FilterProjectEnvsResponseBodyProjectsInternalContentHint,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type:
      FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJson3Type$inboundSchema,
    encryptedValue: types.string(),
  });

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,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(FilterProjectEnvsTargetProjectsResponse1$inboundSchema),
      FilterProjectEnvsTargetProjectsResponse2$inboundSchema,
    ]),
  ),
  type: FilterProjectEnvsResponseBodyProjectsResponse200Type$inboundSchema,
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  value: types.string(),
  vsmValue: types.optional(types.string()),
  id: types.optional(types.string()),
  key: types.string(),
  configurationId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  gitBranch: types.optional(types.string()),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse1$inboundSchema),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse2$inboundSchema
      ),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse3$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse4$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse5$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse6$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse7$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse8$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHintProjectsResponse9$inboundSchema),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse10$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse11$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse12$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse13$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse14$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse15$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse16$inboundSchema
      ),
      z.lazy(() =>
        FilterProjectEnvsContentHintProjectsResponse17$inboundSchema
      ),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() =>
      FilterProjectEnvsResponseBodyProjectsInternalContentHint$inboundSchema
    ),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
  system: types.optional(types.boolean()),
});

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,
  z.ZodTypeDef,
  unknown
> = z.object({
  envs: z.array(z.lazy(() => ResponseBodyEnvs$inboundSchema)),
  hiddenProductionEnvCount: types.number(),
});

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
> = z.nativeEnum(FilterProjectEnvsTargetProjects2);

/** @internal */
export const FilterProjectEnvsTargetProjects1$inboundSchema: z.ZodNativeEnum<
  typeof FilterProjectEnvsTargetProjects1
> = z.nativeEnum(FilterProjectEnvsTargetProjects1);

/** @internal */
export const FilterProjectEnvsResponseBodyProjectsTarget$inboundSchema:
  z.ZodType<
    FilterProjectEnvsResponseBodyProjectsTarget,
    z.ZodTypeDef,
    unknown
  > = smartUnion([
    z.array(FilterProjectEnvsTargetProjects1$inboundSchema),
    FilterProjectEnvsTargetProjects2$inboundSchema,
  ]);

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
    .nativeEnum(FilterProjectEnvsResponseBodyProjectsResponseType);

/** @internal */
export const FilterProjectEnvsContentHintProjects17$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects17,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("flags-connection-string"),
  projectId: types.string(),
});

export function filterProjectEnvsContentHintProjects17FromJSON(
  jsonString: string,
): SafeParseResult<FilterProjectEnvsContentHintProjects17, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      FilterProjectEnvsContentHintProjects17$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FilterProjectEnvsContentHintProjects17' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHintProjects16$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects16,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("integration-store-secret"),
  storeId: types.string(),
  integrationId: types.string(),
  integrationProductId: types.string(),
  integrationConfigurationId: types.string(),
});

export function filterProjectEnvsContentHintProjects16FromJSON(
  jsonString: string,
): SafeParseResult<FilterProjectEnvsContentHintProjects16, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      FilterProjectEnvsContentHintProjects16$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FilterProjectEnvsContentHintProjects16' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHintProjects15$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects15,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-no-ssl"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects14$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects14,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-database"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects13$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects13,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-password"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects12$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects12,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-host"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects11$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects11,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-user"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects10$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects10,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-prisma-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects9$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects9,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-non-pooling"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects8$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects8,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects7$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects7,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-webhook-public-key"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects6$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects6,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-store-id"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects5$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-read-write-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects4$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-read-only-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects3$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects2$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHintProjects1$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHintProjects1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-url"),
  storeId: types.string(),
});

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,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => FilterProjectEnvsContentHintProjects1$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects2$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects3$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects4$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects5$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects6$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects7$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects8$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects9$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects10$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects11$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects12$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects13$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects14$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects15$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects16$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHintProjects17$inboundSchema),
]);

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<
    typeof FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType
  > = z.nativeEnum(
    FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType,
  );

/** @internal */
export const FilterProjectEnvsResponseBodyInternalContentHint$inboundSchema:
  z.ZodType<
    FilterProjectEnvsResponseBodyInternalContentHint,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type:
      FilterProjectEnvsResponseBodyProjectsResponse200ApplicationJSONType$inboundSchema,
    encryptedValue: types.string(),
  });

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({
    target: types.optional(
      smartUnion([
        z.array(FilterProjectEnvsTargetProjects1$inboundSchema),
        FilterProjectEnvsTargetProjects2$inboundSchema,
      ]),
    ),
    type: FilterProjectEnvsResponseBodyProjectsResponseType$inboundSchema,
    sunsetSecretId: types.optional(types.string()),
    legacyValue: types.optional(types.string()),
    decrypted: types.optional(types.boolean()),
    value: types.string(),
    vsmValue: types.optional(types.string()),
    id: types.optional(types.string()),
    key: types.string(),
    configurationId: z.nullable(types.string()).optional(),
    createdAt: types.optional(types.number()),
    updatedAt: types.optional(types.number()),
    createdBy: z.nullable(types.string()).optional(),
    updatedBy: z.nullable(types.string()).optional(),
    gitBranch: types.optional(types.string()),
    edgeConfigId: z.nullable(types.string()).optional(),
    edgeConfigTokenId: z.nullable(types.string()).optional(),
    contentHint: z.nullable(
      z.union([
        z.lazy(() => FilterProjectEnvsContentHintProjects1$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects2$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects3$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects4$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects5$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects6$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects7$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects8$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects9$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects10$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects11$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects12$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects13$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects14$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects15$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects16$inboundSchema),
        z.lazy(() => FilterProjectEnvsContentHintProjects17$inboundSchema),
      ]),
    ).optional(),
    internalContentHint: z.nullable(
      z.lazy(() =>
        FilterProjectEnvsResponseBodyInternalContentHint$inboundSchema
      ),
    ).optional(),
    comment: types.optional(types.string()),
    customEnvironmentIds: types.optional(z.array(types.string())),
    system: types.optional(types.boolean()),
  });

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,
  z.ZodTypeDef,
  unknown
> = z.object({
  envs: z.array(z.lazy(() => Envs$inboundSchema)),
  pagination: Pagination$inboundSchema,
});

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
> = z.nativeEnum(FilterProjectEnvsTarget2);

/** @internal */
export const FilterProjectEnvsTarget1$inboundSchema: z.ZodNativeEnum<
  typeof FilterProjectEnvsTarget1
> = z.nativeEnum(FilterProjectEnvsTarget1);

/** @internal */
export const FilterProjectEnvsResponseBodyTarget$inboundSchema: z.ZodType<
  FilterProjectEnvsResponseBodyTarget,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.array(FilterProjectEnvsTarget1$inboundSchema),
  FilterProjectEnvsTarget2$inboundSchema,
]);

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
> = z.nativeEnum(FilterProjectEnvsResponseBodyType);

/** @internal */
export const FilterProjectEnvsContentHint17$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint17,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("flags-connection-string"),
  projectId: types.string(),
});

export function filterProjectEnvsContentHint17FromJSON(
  jsonString: string,
): SafeParseResult<FilterProjectEnvsContentHint17, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => FilterProjectEnvsContentHint17$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FilterProjectEnvsContentHint17' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHint16$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint16,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("integration-store-secret"),
  storeId: types.string(),
  integrationId: types.string(),
  integrationProductId: types.string(),
  integrationConfigurationId: types.string(),
});

export function filterProjectEnvsContentHint16FromJSON(
  jsonString: string,
): SafeParseResult<FilterProjectEnvsContentHint16, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => FilterProjectEnvsContentHint16$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FilterProjectEnvsContentHint16' from JSON`,
  );
}

/** @internal */
export const FilterProjectEnvsContentHint15$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint15,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-no-ssl"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint14$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint14,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-database"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint13$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint13,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-password"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint12$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint12,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-host"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint11$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint11,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-user"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint10$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint10,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-prisma-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint9$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint9,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-non-pooling"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint8$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint8,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint7$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint7,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-webhook-public-key"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint6$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint6,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-store-id"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint5$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-read-write-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint4$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-read-only-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint3$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-token"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint2$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-url"),
  storeId: types.string(),
});

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 FilterProjectEnvsContentHint1$inboundSchema: z.ZodType<
  FilterProjectEnvsContentHint1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-url"),
  storeId: types.string(),
});

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,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => FilterProjectEnvsContentHint1$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint2$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint3$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint4$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint5$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint6$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint7$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint8$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint9$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint10$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint11$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint12$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint13$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint14$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint15$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint16$inboundSchema),
  z.lazy(() => FilterProjectEnvsContentHint17$inboundSchema),
]);

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
    .nativeEnum(FilterProjectEnvsResponseBodyProjectsType);

/** @internal */
export const ResponseBodyInternalContentHint$inboundSchema: z.ZodType<
  ResponseBodyInternalContentHint,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: FilterProjectEnvsResponseBodyProjectsType$inboundSchema,
  encryptedValue: types.string(),
});

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,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(FilterProjectEnvsTarget1$inboundSchema),
      FilterProjectEnvsTarget2$inboundSchema,
    ]),
  ),
  type: FilterProjectEnvsResponseBodyType$inboundSchema,
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  value: types.string(),
  vsmValue: types.optional(types.string()),
  id: types.optional(types.string()),
  key: types.string(),
  configurationId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  gitBranch: types.optional(types.string()),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => FilterProjectEnvsContentHint1$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint2$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint3$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint4$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint5$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint6$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint7$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint8$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint9$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint10$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint11$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint12$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint13$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint14$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint15$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint16$inboundSchema),
      z.lazy(() => FilterProjectEnvsContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => ResponseBodyInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
  system: types.optional(types.boolean()),
});

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,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => FilterProjectEnvsResponseBody1$inboundSchema),
  z.lazy(() => FilterProjectEnvsResponseBody2$inboundSchema),
  z.lazy(() => FilterProjectEnvsResponseBody3$inboundSchema),
]);

export function filterProjectEnvsResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<FilterProjectEnvsResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => FilterProjectEnvsResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FilterProjectEnvsResponseBody' from JSON`,
  );
}