/*
 * 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 { SDKValidationError } from "./sdkvalidationerror.js";

export type RemoveProjectEnvRequest = {
  /**
   * The unique project identifier or the project name
   */
  idOrName: string;
  /**
   * The unique environment variable identifier
   */
  id: string;
  /**
   * The unique custom environment identifier within the project
   */
  customEnvironmentId?: 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 RemoveProjectEnvResponseBodyProjectsResponseType = {
  Encrypted: "encrypted",
  Plain: "plain",
  Secret: "secret",
  Sensitive: "sensitive",
  System: "system",
} as const;
export type RemoveProjectEnvResponseBodyProjectsResponseType = ClosedEnum<
  typeof RemoveProjectEnvResponseBodyProjectsResponseType
>;

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

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

export type RemoveProjectEnvResponseBodyProjectsResponseTarget =
  | Array<RemoveProjectEnvTargetProjectsResponse1>
  | RemoveProjectEnvTargetProjectsResponse2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type RemoveProjectEnvResponseBodyProjectsResponseContentHint =
  | RemoveProjectEnvContentHintProjectsResponse1
  | RemoveProjectEnvContentHintProjectsResponse2
  | RemoveProjectEnvContentHintProjectsResponse3
  | RemoveProjectEnvContentHintProjectsResponse4
  | RemoveProjectEnvContentHintProjectsResponse5
  | RemoveProjectEnvContentHintProjectsResponse6
  | RemoveProjectEnvContentHintProjectsResponse7
  | RemoveProjectEnvContentHintProjectsResponse8
  | RemoveProjectEnvContentHintProjectsResponse9
  | RemoveProjectEnvContentHintProjectsResponse10
  | RemoveProjectEnvContentHintProjectsResponse11
  | RemoveProjectEnvContentHintProjectsResponse12
  | RemoveProjectEnvContentHintProjectsResponse13
  | RemoveProjectEnvContentHintProjectsResponse14
  | RemoveProjectEnvContentHintProjectsResponse15
  | RemoveProjectEnvContentHintProjectsResponse16
  | RemoveProjectEnvContentHintProjectsResponse17;

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

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

export type RemoveProjectEnvResponseBody3 = {
  type: RemoveProjectEnvResponseBodyProjectsResponseType;
  value: string;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  id?: string | undefined;
  key: string;
  target?:
    | Array<RemoveProjectEnvTargetProjectsResponse1>
    | RemoveProjectEnvTargetProjectsResponse2
    | undefined;
  gitBranch?: string | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  /**
   * 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;
  configurationId?: string | null | undefined;
  contentHint?:
    | RemoveProjectEnvContentHintProjectsResponse1
    | RemoveProjectEnvContentHintProjectsResponse2
    | RemoveProjectEnvContentHintProjectsResponse3
    | RemoveProjectEnvContentHintProjectsResponse4
    | RemoveProjectEnvContentHintProjectsResponse5
    | RemoveProjectEnvContentHintProjectsResponse6
    | RemoveProjectEnvContentHintProjectsResponse7
    | RemoveProjectEnvContentHintProjectsResponse8
    | RemoveProjectEnvContentHintProjectsResponse9
    | RemoveProjectEnvContentHintProjectsResponse10
    | RemoveProjectEnvContentHintProjectsResponse11
    | RemoveProjectEnvContentHintProjectsResponse12
    | RemoveProjectEnvContentHintProjectsResponse13
    | RemoveProjectEnvContentHintProjectsResponse14
    | RemoveProjectEnvContentHintProjectsResponse15
    | RemoveProjectEnvContentHintProjectsResponse16
    | RemoveProjectEnvContentHintProjectsResponse17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | RemoveProjectEnvResponseBodyProjectsResponseInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

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

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

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

export type RemoveProjectEnvResponseBodyProjectsTarget =
  | Array<RemoveProjectEnvTargetProjects1>
  | RemoveProjectEnvTargetProjects2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type RemoveProjectEnvResponseBodyProjectsContentHint =
  | RemoveProjectEnvContentHintProjects1
  | RemoveProjectEnvContentHintProjects2
  | RemoveProjectEnvContentHintProjects3
  | RemoveProjectEnvContentHintProjects4
  | RemoveProjectEnvContentHintProjects5
  | RemoveProjectEnvContentHintProjects6
  | RemoveProjectEnvContentHintProjects7
  | RemoveProjectEnvContentHintProjects8
  | RemoveProjectEnvContentHintProjects9
  | RemoveProjectEnvContentHintProjects10
  | RemoveProjectEnvContentHintProjects11
  | RemoveProjectEnvContentHintProjects12
  | RemoveProjectEnvContentHintProjects13
  | RemoveProjectEnvContentHintProjects14
  | RemoveProjectEnvContentHintProjects15
  | RemoveProjectEnvContentHintProjects16
  | RemoveProjectEnvContentHintProjects17;

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

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

export type RemoveProjectEnvResponseBody2 = {
  system?: boolean | undefined;
  type: RemoveProjectEnvResponseBodyProjectsType;
  value: string;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  id?: string | undefined;
  key: string;
  target?:
    | Array<RemoveProjectEnvTargetProjects1>
    | RemoveProjectEnvTargetProjects2
    | undefined;
  gitBranch?: string | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  /**
   * 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;
  configurationId?: string | null | undefined;
  contentHint?:
    | RemoveProjectEnvContentHintProjects1
    | RemoveProjectEnvContentHintProjects2
    | RemoveProjectEnvContentHintProjects3
    | RemoveProjectEnvContentHintProjects4
    | RemoveProjectEnvContentHintProjects5
    | RemoveProjectEnvContentHintProjects6
    | RemoveProjectEnvContentHintProjects7
    | RemoveProjectEnvContentHintProjects8
    | RemoveProjectEnvContentHintProjects9
    | RemoveProjectEnvContentHintProjects10
    | RemoveProjectEnvContentHintProjects11
    | RemoveProjectEnvContentHintProjects12
    | RemoveProjectEnvContentHintProjects13
    | RemoveProjectEnvContentHintProjects14
    | RemoveProjectEnvContentHintProjects15
    | RemoveProjectEnvContentHintProjects16
    | RemoveProjectEnvContentHintProjects17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | RemoveProjectEnvResponseBodyProjectsInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

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

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

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

export type RemoveProjectEnvResponseBodyTarget =
  | Array<RemoveProjectEnvTarget1>
  | RemoveProjectEnvTarget2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type RemoveProjectEnvResponseBodyContentHint =
  | RemoveProjectEnvContentHint1
  | RemoveProjectEnvContentHint2
  | RemoveProjectEnvContentHint3
  | RemoveProjectEnvContentHint4
  | RemoveProjectEnvContentHint5
  | RemoveProjectEnvContentHint6
  | RemoveProjectEnvContentHint7
  | RemoveProjectEnvContentHint8
  | RemoveProjectEnvContentHint9
  | RemoveProjectEnvContentHint10
  | RemoveProjectEnvContentHint11
  | RemoveProjectEnvContentHint12
  | RemoveProjectEnvContentHint13
  | RemoveProjectEnvContentHint14
  | RemoveProjectEnvContentHint15
  | RemoveProjectEnvContentHint16
  | RemoveProjectEnvContentHint17;

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

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

export type RemoveProjectEnvResponseBody1 = {
  type: RemoveProjectEnvResponseBodyType;
  value: string;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  id?: string | undefined;
  key: string;
  target?: Array<RemoveProjectEnvTarget1> | RemoveProjectEnvTarget2 | undefined;
  gitBranch?: string | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  /**
   * 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;
  configurationId?: string | null | undefined;
  contentHint?:
    | RemoveProjectEnvContentHint1
    | RemoveProjectEnvContentHint2
    | RemoveProjectEnvContentHint3
    | RemoveProjectEnvContentHint4
    | RemoveProjectEnvContentHint5
    | RemoveProjectEnvContentHint6
    | RemoveProjectEnvContentHint7
    | RemoveProjectEnvContentHint8
    | RemoveProjectEnvContentHint9
    | RemoveProjectEnvContentHint10
    | RemoveProjectEnvContentHint11
    | RemoveProjectEnvContentHint12
    | RemoveProjectEnvContentHint13
    | RemoveProjectEnvContentHint14
    | RemoveProjectEnvContentHint15
    | RemoveProjectEnvContentHint16
    | RemoveProjectEnvContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | RemoveProjectEnvResponseBodyInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

/**
 * The environment variable was successfully removed
 */
export type RemoveProjectEnvResponseBody =
  | RemoveProjectEnvResponseBody2
  | RemoveProjectEnvResponseBody3
  | Array<RemoveProjectEnvResponseBody1>;

/** @internal */
export type RemoveProjectEnvRequest$Outbound = {
  idOrName: string;
  id: string;
  customEnvironmentId?: string | undefined;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const RemoveProjectEnvRequest$outboundSchema: z.ZodType<
  RemoveProjectEnvRequest$Outbound,
  z.ZodTypeDef,
  RemoveProjectEnvRequest
> = z.object({
  idOrName: z.string(),
  id: z.string(),
  customEnvironmentId: z.string().optional(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function removeProjectEnvRequestToJSON(
  removeProjectEnvRequest: RemoveProjectEnvRequest,
): string {
  return JSON.stringify(
    RemoveProjectEnvRequest$outboundSchema.parse(removeProjectEnvRequest),
  );
}

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse16$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse16,
    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 removeProjectEnvContentHintProjectsResponse16FromJSON(
  jsonString: string,
): SafeParseResult<
  RemoveProjectEnvContentHintProjectsResponse16,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      RemoveProjectEnvContentHintProjectsResponse16$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'RemoveProjectEnvContentHintProjectsResponse16' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse7$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse7,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-webhook-public-key"),
    storeId: types.string(),
  });

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse6$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse6,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-store-id"),
    storeId: types.string(),
  });

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse5$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse5,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("blob-read-write-token"),
    storeId: types.string(),
  });

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse4$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse4,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-rest-api-read-only-token"),
    storeId: types.string(),
  });

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

/** @internal */
export const RemoveProjectEnvContentHintProjectsResponse3$inboundSchema:
  z.ZodType<
    RemoveProjectEnvContentHintProjectsResponse3,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("redis-rest-api-token"),
    storeId: types.string(),
  });

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBodyProjectsResponseContentHint$inboundSchema:
  z.ZodType<
    RemoveProjectEnvResponseBodyProjectsResponseContentHint,
    z.ZodTypeDef,
    unknown
  > = z.union([
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse1$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse2$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse3$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse4$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse5$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse6$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse7$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse8$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse9$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse10$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse11$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse12$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse13$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse14$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse15$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse16$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjectsResponse17$inboundSchema),
  ]);

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBody3$inboundSchema: z.ZodType<
  RemoveProjectEnvResponseBody3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: RemoveProjectEnvResponseBodyProjectsResponseType$inboundSchema,
  value: types.string(),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  id: types.optional(types.string()),
  key: types.string(),
  target: types.optional(
    smartUnion([
      z.array(RemoveProjectEnvTargetProjectsResponse1$inboundSchema),
      RemoveProjectEnvTargetProjectsResponse2$inboundSchema,
    ]),
  ),
  gitBranch: types.optional(types.string()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  configurationId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse1$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse2$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse3$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse4$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse5$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse6$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse7$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse8$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse9$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse10$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse11$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse12$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse13$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse14$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse15$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse16$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjectsResponse17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() =>
      RemoveProjectEnvResponseBodyProjectsResponseInternalContentHint$inboundSchema
    ),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHintProjects16$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects16,
  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 removeProjectEnvContentHintProjects16FromJSON(
  jsonString: string,
): SafeParseResult<RemoveProjectEnvContentHintProjects16, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      RemoveProjectEnvContentHintProjects16$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'RemoveProjectEnvContentHintProjects16' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHintProjects7$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects7,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-webhook-public-key"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHintProjects6$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects6,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-store-id"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHintProjects5$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-read-write-token"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHintProjects4$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-read-only-token"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHintProjects3$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHintProjects3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-token"),
  storeId: types.string(),
});

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBodyProjectsContentHint$inboundSchema:
  z.ZodType<
    RemoveProjectEnvResponseBodyProjectsContentHint,
    z.ZodTypeDef,
    unknown
  > = z.union([
    z.lazy(() => RemoveProjectEnvContentHintProjects1$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects2$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects3$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects4$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects5$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects6$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects7$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects8$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects9$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects10$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects11$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects12$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects13$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects14$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects15$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects16$inboundSchema),
    z.lazy(() => RemoveProjectEnvContentHintProjects17$inboundSchema),
  ]);

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBody2$inboundSchema: z.ZodType<
  RemoveProjectEnvResponseBody2,
  z.ZodTypeDef,
  unknown
> = z.object({
  system: types.optional(types.boolean()),
  type: RemoveProjectEnvResponseBodyProjectsType$inboundSchema,
  value: types.string(),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  id: types.optional(types.string()),
  key: types.string(),
  target: types.optional(
    smartUnion([
      z.array(RemoveProjectEnvTargetProjects1$inboundSchema),
      RemoveProjectEnvTargetProjects2$inboundSchema,
    ]),
  ),
  gitBranch: types.optional(types.string()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  configurationId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => RemoveProjectEnvContentHintProjects1$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects2$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects3$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects4$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects5$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects6$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects7$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects8$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects9$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects10$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects11$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects12$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects13$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects14$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects15$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects16$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHintProjects17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() =>
      RemoveProjectEnvResponseBodyProjectsInternalContentHint$inboundSchema
    ),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHint16$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint16,
  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 removeProjectEnvContentHint16FromJSON(
  jsonString: string,
): SafeParseResult<RemoveProjectEnvContentHint16, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => RemoveProjectEnvContentHint16$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'RemoveProjectEnvContentHint16' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvContentHint7$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint7,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-webhook-public-key"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHint6$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint6,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-store-id"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHint5$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-read-write-token"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHint4$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-read-only-token"),
  storeId: types.string(),
});

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

/** @internal */
export const RemoveProjectEnvContentHint3$inboundSchema: z.ZodType<
  RemoveProjectEnvContentHint3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-token"),
  storeId: types.string(),
});

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

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBodyContentHint$inboundSchema: z.ZodType<
  RemoveProjectEnvResponseBodyContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => RemoveProjectEnvContentHint1$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint2$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint3$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint4$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint5$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint6$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint7$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint8$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint9$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint10$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint11$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint12$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint13$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint14$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint15$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint16$inboundSchema),
  z.lazy(() => RemoveProjectEnvContentHint17$inboundSchema),
]);

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

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

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

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

/** @internal */
export const RemoveProjectEnvResponseBody1$inboundSchema: z.ZodType<
  RemoveProjectEnvResponseBody1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: RemoveProjectEnvResponseBodyType$inboundSchema,
  value: types.string(),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  id: types.optional(types.string()),
  key: types.string(),
  target: types.optional(
    smartUnion([
      z.array(RemoveProjectEnvTarget1$inboundSchema),
      RemoveProjectEnvTarget2$inboundSchema,
    ]),
  ),
  gitBranch: types.optional(types.string()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  configurationId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => RemoveProjectEnvContentHint1$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint2$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint3$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint4$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint5$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint6$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint7$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint8$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint9$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint10$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint11$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint12$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint13$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint14$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint15$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint16$inboundSchema),
      z.lazy(() => RemoveProjectEnvContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => RemoveProjectEnvResponseBodyInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

/** @internal */
export const RemoveProjectEnvResponseBody$inboundSchema: z.ZodType<
  RemoveProjectEnvResponseBody,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => RemoveProjectEnvResponseBody2$inboundSchema),
  z.lazy(() => RemoveProjectEnvResponseBody3$inboundSchema),
  z.array(z.lazy(() => RemoveProjectEnvResponseBody1$inboundSchema)),
]);

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