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

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

/**
 * The type of environment variable
 */
export const CreateProjectEnv2Type = {
  System: "system",
  Encrypted: "encrypted",
  Plain: "plain",
  Sensitive: "sensitive",
} as const;
/**
 * The type of environment variable
 */
export type CreateProjectEnv2Type = ClosedEnum<typeof CreateProjectEnv2Type>;

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

export type CreateProjectEnv22 = {
  /**
   * The name of the environment variable
   */
  key: string;
  /**
   * The value of the environment variable
   */
  value: string;
  /**
   * The type of environment variable
   */
  type: CreateProjectEnv2Type;
  /**
   * The target environment of the environment variable
   */
  target?: Array<CreateProjectEnv2Target> | undefined;
  /**
   * If defined, the git branch of the environment variable (must have target=preview)
   */
  gitBranch?: string | null | undefined;
  /**
   * A comment to add context on what this environment variable is for
   */
  comment?: string | undefined;
  /**
   * The custom environment IDs associated with the environment variable
   */
  customEnvironmentIds: Array<string>;
};

/**
 * The type of environment variable
 */
export const TwoType = {
  System: "system",
  Encrypted: "encrypted",
  Plain: "plain",
  Sensitive: "sensitive",
} as const;
/**
 * The type of environment variable
 */
export type TwoType = ClosedEnum<typeof TwoType>;

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

export type CreateProjectEnv21 = {
  /**
   * The name of the environment variable
   */
  key: string;
  /**
   * The value of the environment variable
   */
  value: string;
  /**
   * The type of environment variable
   */
  type: TwoType;
  /**
   * The target environment of the environment variable
   */
  target: Array<TwoTarget>;
  /**
   * If defined, the git branch of the environment variable (must have target=preview)
   */
  gitBranch?: string | null | undefined;
  /**
   * A comment to add context on what this environment variable is for
   */
  comment?: string | undefined;
  /**
   * The custom environment IDs associated with the environment variable
   */
  customEnvironmentIds?: Array<string> | undefined;
};

export type CreateProjectEnvRequestBody2 =
  | CreateProjectEnv21
  | CreateProjectEnv22;

/**
 * The type of environment variable
 */
export const CreateProjectEnv1Type = {
  System: "system",
  Encrypted: "encrypted",
  Plain: "plain",
  Sensitive: "sensitive",
} as const;
/**
 * The type of environment variable
 */
export type CreateProjectEnv1Type = ClosedEnum<typeof CreateProjectEnv1Type>;

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

export type CreateProjectEnv12 = {
  /**
   * The name of the environment variable
   */
  key: string;
  /**
   * The value of the environment variable
   */
  value: string;
  /**
   * The type of environment variable
   */
  type: CreateProjectEnv1Type;
  /**
   * The target environment of the environment variable
   */
  target?: Array<CreateProjectEnv1Target> | undefined;
  /**
   * If defined, the git branch of the environment variable (must have target=preview)
   */
  gitBranch?: string | null | undefined;
  /**
   * A comment to add context on what this environment variable is for
   */
  comment?: string | undefined;
  /**
   * The custom environment IDs associated with the environment variable
   */
  customEnvironmentIds: Array<string>;
};

/**
 * The type of environment variable
 */
export const OneType = {
  System: "system",
  Encrypted: "encrypted",
  Plain: "plain",
  Sensitive: "sensitive",
} as const;
/**
 * The type of environment variable
 */
export type OneType = ClosedEnum<typeof OneType>;

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

export type CreateProjectEnv11 = {
  /**
   * The name of the environment variable
   */
  key: string;
  /**
   * The value of the environment variable
   */
  value: string;
  /**
   * The type of environment variable
   */
  type: OneType;
  /**
   * The target environment of the environment variable
   */
  target: Array<OneTarget>;
  /**
   * If defined, the git branch of the environment variable (must have target=preview)
   */
  gitBranch?: string | null | undefined;
  /**
   * A comment to add context on what this environment variable is for
   */
  comment?: string | undefined;
  /**
   * The custom environment IDs associated with the environment variable
   */
  customEnvironmentIds?: Array<string> | undefined;
};

export type CreateProjectEnvRequestBody1 =
  | CreateProjectEnv11
  | CreateProjectEnv12;

export type CreateProjectEnvRequestBody =
  | CreateProjectEnv11
  | CreateProjectEnv12
  | Array<CreateProjectEnv21 | CreateProjectEnv22>;

export type CreateProjectEnvRequest = {
  /**
   * The unique project identifier or the project name
   */
  idOrName: string;
  /**
   * Allow override of environment variable if it already exists
   */
  upsert?: 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;
  requestBody:
    | CreateProjectEnv11
    | CreateProjectEnv12
    | Array<CreateProjectEnv21 | CreateProjectEnv22>;
};

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

export type CreateProjectEnvCreatedTarget =
  | Array<string>
  | CreateProjectEnvTargetProjects2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type CreateProjectEnvCreatedContentHint =
  | CreateProjectEnvContentHintProjects1
  | CreateProjectEnvContentHintProjects2
  | CreateProjectEnvContentHintProjects3
  | CreateProjectEnvContentHintProjects4
  | CreateProjectEnvContentHintProjects5
  | CreateProjectEnvContentHintProjects6
  | CreateProjectEnvContentHintProjects7
  | CreateProjectEnvContentHintProjects8
  | CreateProjectEnvContentHintProjects9
  | CreateProjectEnvContentHintProjects10
  | CreateProjectEnvContentHintProjects11
  | CreateProjectEnvContentHintProjects12
  | CreateProjectEnvContentHintProjects13
  | CreateProjectEnvContentHintProjects14
  | CreateProjectEnvContentHintProjects15
  | CreateProjectEnvContentHintProjects16
  | CreateProjectEnvContentHintProjects17;

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

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

export type Created2 = {
  target?: Array<string> | CreateProjectEnvTargetProjects2 | undefined;
  type: CreateProjectEnvCreatedType;
  /**
   * 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?:
    | CreateProjectEnvContentHintProjects1
    | CreateProjectEnvContentHintProjects2
    | CreateProjectEnvContentHintProjects3
    | CreateProjectEnvContentHintProjects4
    | CreateProjectEnvContentHintProjects5
    | CreateProjectEnvContentHintProjects6
    | CreateProjectEnvContentHintProjects7
    | CreateProjectEnvContentHintProjects8
    | CreateProjectEnvContentHintProjects9
    | CreateProjectEnvContentHintProjects10
    | CreateProjectEnvContentHintProjects11
    | CreateProjectEnvContentHintProjects12
    | CreateProjectEnvContentHintProjects13
    | CreateProjectEnvContentHintProjects14
    | CreateProjectEnvContentHintProjects15
    | CreateProjectEnvContentHintProjects16
    | CreateProjectEnvContentHintProjects17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | CreateProjectEnvCreatedInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
  system?: boolean | undefined;
};

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

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

export type CreatedTarget =
  | Array<CreateProjectEnvTarget1>
  | CreateProjectEnvTarget2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type CreatedContentHint =
  | CreateProjectEnvContentHint1
  | CreateProjectEnvContentHint2
  | CreateProjectEnvContentHint3
  | CreateProjectEnvContentHint4
  | CreateProjectEnvContentHint5
  | CreateProjectEnvContentHint6
  | CreateProjectEnvContentHint7
  | CreateProjectEnvContentHint8
  | CreateProjectEnvContentHint9
  | CreateProjectEnvContentHint10
  | CreateProjectEnvContentHint11
  | CreateProjectEnvContentHint12
  | CreateProjectEnvContentHint13
  | CreateProjectEnvContentHint14
  | CreateProjectEnvContentHint15
  | CreateProjectEnvContentHint16
  | CreateProjectEnvContentHint17;

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

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

export type Created1 = {
  target?: Array<CreateProjectEnvTarget1> | CreateProjectEnvTarget2 | undefined;
  type: CreatedType;
  /**
   * 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?:
    | CreateProjectEnvContentHint1
    | CreateProjectEnvContentHint2
    | CreateProjectEnvContentHint3
    | CreateProjectEnvContentHint4
    | CreateProjectEnvContentHint5
    | CreateProjectEnvContentHint6
    | CreateProjectEnvContentHint7
    | CreateProjectEnvContentHint8
    | CreateProjectEnvContentHint9
    | CreateProjectEnvContentHint10
    | CreateProjectEnvContentHint11
    | CreateProjectEnvContentHint12
    | CreateProjectEnvContentHint13
    | CreateProjectEnvContentHint14
    | CreateProjectEnvContentHint15
    | CreateProjectEnvContentHint16
    | CreateProjectEnvContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?: CreatedInternalContentHint | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
  system?: boolean | undefined;
};

export type CreateProjectEnvCreated = Created1 | Array<Created2>;

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

export type CreateProjectEnvValue = string | Array<CreateProjectEnvValue2>;

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

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

export type CreateProjectEnvTarget =
  | Array<CreateProjectEnvTargetProjects1>
  | CreateProjectEnvTargetProjectsResponse2;

export type CreateProjectEnvError = {
  code: string;
  message: string;
  key?: string | undefined;
  envVarId?: string | undefined;
  envVarKey?: string | undefined;
  action?: string | undefined;
  link?: string | undefined;
  value?: string | Array<CreateProjectEnvValue2> | undefined;
  gitBranch?: string | undefined;
  target?:
    | Array<CreateProjectEnvTargetProjects1>
    | CreateProjectEnvTargetProjectsResponse2
    | undefined;
  project?: string | undefined;
};

export type CreateProjectEnvFailed = {
  error: CreateProjectEnvError;
};

/**
 * The environment variable was created successfully
 */
export type CreateProjectEnvResponseBody = {
  created: Created1 | Array<Created2>;
  failed: Array<CreateProjectEnvFailed>;
};

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

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

/** @internal */
export type CreateProjectEnv22$Outbound = {
  key: string;
  value: string;
  type: string;
  target?: Array<string> | undefined;
  gitBranch?: string | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds: Array<string>;
};

/** @internal */
export const CreateProjectEnv22$outboundSchema: z.ZodType<
  CreateProjectEnv22$Outbound,
  z.ZodTypeDef,
  CreateProjectEnv22
> = z.object({
  key: z.string(),
  value: z.string(),
  type: CreateProjectEnv2Type$outboundSchema,
  target: z.array(CreateProjectEnv2Target$outboundSchema).optional(),
  gitBranch: z.nullable(z.string()).optional(),
  comment: z.string().optional(),
  customEnvironmentIds: z.array(z.string()),
});

export function createProjectEnv22ToJSON(
  createProjectEnv22: CreateProjectEnv22,
): string {
  return JSON.stringify(
    CreateProjectEnv22$outboundSchema.parse(createProjectEnv22),
  );
}

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

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

/** @internal */
export type CreateProjectEnv21$Outbound = {
  key: string;
  value: string;
  type: string;
  target: Array<string>;
  gitBranch?: string | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

/** @internal */
export const CreateProjectEnv21$outboundSchema: z.ZodType<
  CreateProjectEnv21$Outbound,
  z.ZodTypeDef,
  CreateProjectEnv21
> = z.object({
  key: z.string(),
  value: z.string(),
  type: TwoType$outboundSchema,
  target: z.array(TwoTarget$outboundSchema),
  gitBranch: z.nullable(z.string()).optional(),
  comment: z.string().optional(),
  customEnvironmentIds: z.array(z.string()).optional(),
});

export function createProjectEnv21ToJSON(
  createProjectEnv21: CreateProjectEnv21,
): string {
  return JSON.stringify(
    CreateProjectEnv21$outboundSchema.parse(createProjectEnv21),
  );
}

/** @internal */
export type CreateProjectEnvRequestBody2$Outbound =
  | CreateProjectEnv21$Outbound
  | CreateProjectEnv22$Outbound;

/** @internal */
export const CreateProjectEnvRequestBody2$outboundSchema: z.ZodType<
  CreateProjectEnvRequestBody2$Outbound,
  z.ZodTypeDef,
  CreateProjectEnvRequestBody2
> = smartUnion([
  z.lazy(() => CreateProjectEnv21$outboundSchema),
  z.lazy(() => CreateProjectEnv22$outboundSchema),
]);

export function createProjectEnvRequestBody2ToJSON(
  createProjectEnvRequestBody2: CreateProjectEnvRequestBody2,
): string {
  return JSON.stringify(
    CreateProjectEnvRequestBody2$outboundSchema.parse(
      createProjectEnvRequestBody2,
    ),
  );
}

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

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

/** @internal */
export type CreateProjectEnv12$Outbound = {
  key: string;
  value: string;
  type: string;
  target?: Array<string> | undefined;
  gitBranch?: string | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds: Array<string>;
};

/** @internal */
export const CreateProjectEnv12$outboundSchema: z.ZodType<
  CreateProjectEnv12$Outbound,
  z.ZodTypeDef,
  CreateProjectEnv12
> = z.object({
  key: z.string(),
  value: z.string(),
  type: CreateProjectEnv1Type$outboundSchema,
  target: z.array(CreateProjectEnv1Target$outboundSchema).optional(),
  gitBranch: z.nullable(z.string()).optional(),
  comment: z.string().optional(),
  customEnvironmentIds: z.array(z.string()),
});

export function createProjectEnv12ToJSON(
  createProjectEnv12: CreateProjectEnv12,
): string {
  return JSON.stringify(
    CreateProjectEnv12$outboundSchema.parse(createProjectEnv12),
  );
}

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

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

/** @internal */
export type CreateProjectEnv11$Outbound = {
  key: string;
  value: string;
  type: string;
  target: Array<string>;
  gitBranch?: string | null | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

/** @internal */
export const CreateProjectEnv11$outboundSchema: z.ZodType<
  CreateProjectEnv11$Outbound,
  z.ZodTypeDef,
  CreateProjectEnv11
> = z.object({
  key: z.string(),
  value: z.string(),
  type: OneType$outboundSchema,
  target: z.array(OneTarget$outboundSchema),
  gitBranch: z.nullable(z.string()).optional(),
  comment: z.string().optional(),
  customEnvironmentIds: z.array(z.string()).optional(),
});

export function createProjectEnv11ToJSON(
  createProjectEnv11: CreateProjectEnv11,
): string {
  return JSON.stringify(
    CreateProjectEnv11$outboundSchema.parse(createProjectEnv11),
  );
}

/** @internal */
export type CreateProjectEnvRequestBody1$Outbound =
  | CreateProjectEnv11$Outbound
  | CreateProjectEnv12$Outbound;

/** @internal */
export const CreateProjectEnvRequestBody1$outboundSchema: z.ZodType<
  CreateProjectEnvRequestBody1$Outbound,
  z.ZodTypeDef,
  CreateProjectEnvRequestBody1
> = smartUnion([
  z.lazy(() => CreateProjectEnv11$outboundSchema),
  z.lazy(() => CreateProjectEnv12$outboundSchema),
]);

export function createProjectEnvRequestBody1ToJSON(
  createProjectEnvRequestBody1: CreateProjectEnvRequestBody1,
): string {
  return JSON.stringify(
    CreateProjectEnvRequestBody1$outboundSchema.parse(
      createProjectEnvRequestBody1,
    ),
  );
}

/** @internal */
export type CreateProjectEnvRequestBody$Outbound =
  | CreateProjectEnv11$Outbound
  | CreateProjectEnv12$Outbound
  | Array<CreateProjectEnv21$Outbound | CreateProjectEnv22$Outbound>;

/** @internal */
export const CreateProjectEnvRequestBody$outboundSchema: z.ZodType<
  CreateProjectEnvRequestBody$Outbound,
  z.ZodTypeDef,
  CreateProjectEnvRequestBody
> = smartUnion([
  smartUnion([
    z.lazy(() => CreateProjectEnv11$outboundSchema),
    z.lazy(() => CreateProjectEnv12$outboundSchema),
  ]),
  z.array(
    smartUnion([
      z.lazy(() => CreateProjectEnv21$outboundSchema),
      z.lazy(() => CreateProjectEnv22$outboundSchema),
    ]),
  ),
]);

export function createProjectEnvRequestBodyToJSON(
  createProjectEnvRequestBody: CreateProjectEnvRequestBody,
): string {
  return JSON.stringify(
    CreateProjectEnvRequestBody$outboundSchema.parse(
      createProjectEnvRequestBody,
    ),
  );
}

/** @internal */
export type CreateProjectEnvRequest$Outbound = {
  idOrName: string;
  upsert?: string | undefined;
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody:
    | CreateProjectEnv11$Outbound
    | CreateProjectEnv12$Outbound
    | Array<CreateProjectEnv21$Outbound | CreateProjectEnv22$Outbound>;
};

/** @internal */
export const CreateProjectEnvRequest$outboundSchema: z.ZodType<
  CreateProjectEnvRequest$Outbound,
  z.ZodTypeDef,
  CreateProjectEnvRequest
> = z.object({
  idOrName: z.string(),
  upsert: z.string().optional(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: smartUnion([
    smartUnion([
      z.lazy(() => CreateProjectEnv11$outboundSchema),
      z.lazy(() => CreateProjectEnv12$outboundSchema),
    ]),
    z.array(
      smartUnion([
        z.lazy(() => CreateProjectEnv21$outboundSchema),
        z.lazy(() => CreateProjectEnv22$outboundSchema),
      ]),
    ),
  ]),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function createProjectEnvRequestToJSON(
  createProjectEnvRequest: CreateProjectEnvRequest,
): string {
  return JSON.stringify(
    CreateProjectEnvRequest$outboundSchema.parse(createProjectEnvRequest),
  );
}

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

/** @internal */
export const CreateProjectEnvCreatedTarget$inboundSchema: z.ZodType<
  CreateProjectEnvCreatedTarget,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.array(types.string()),
  CreateProjectEnvTargetProjects2$inboundSchema,
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const CreateProjectEnvCreatedContentHint$inboundSchema: z.ZodType<
  CreateProjectEnvCreatedContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => CreateProjectEnvContentHintProjects1$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects2$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects3$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects4$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects5$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects6$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects7$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects8$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects9$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects10$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects11$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects12$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects13$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects14$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects15$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects16$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHintProjects17$inboundSchema),
]);

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

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

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

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

/** @internal */
export const Created2$inboundSchema: z.ZodType<
  Created2,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(types.string()),
      CreateProjectEnvTargetProjects2$inboundSchema,
    ]),
  ),
  type: CreateProjectEnvCreatedType$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(() => CreateProjectEnvContentHintProjects1$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects2$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects3$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects4$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects5$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects6$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects7$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects8$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects9$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects10$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects11$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects12$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects13$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects14$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects15$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects16$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHintProjects17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => CreateProjectEnvCreatedInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
  system: types.optional(types.boolean()),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const CreatedContentHint$inboundSchema: z.ZodType<
  CreatedContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => CreateProjectEnvContentHint1$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint2$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint3$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint4$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint5$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint6$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint7$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint8$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint9$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint10$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint11$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint12$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint13$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint14$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint15$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint16$inboundSchema),
  z.lazy(() => CreateProjectEnvContentHint17$inboundSchema),
]);

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

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

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

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

/** @internal */
export const Created1$inboundSchema: z.ZodType<
  Created1,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(CreateProjectEnvTarget1$inboundSchema),
      CreateProjectEnvTarget2$inboundSchema,
    ]),
  ),
  type: CreatedType$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(() => CreateProjectEnvContentHint1$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint2$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint3$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint4$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint5$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint6$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint7$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint8$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint9$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint10$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint11$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint12$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint13$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint14$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint15$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint16$inboundSchema),
      z.lazy(() => CreateProjectEnvContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => CreatedInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
  system: types.optional(types.boolean()),
});

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

/** @internal */
export const CreateProjectEnvCreated$inboundSchema: z.ZodType<
  CreateProjectEnvCreated,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => Created1$inboundSchema),
  z.array(z.lazy(() => Created2$inboundSchema)),
]);

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

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

/** @internal */
export const CreateProjectEnvValue$inboundSchema: z.ZodType<
  CreateProjectEnvValue,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), z.array(CreateProjectEnvValue2$inboundSchema)]);

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

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

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

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

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

/** @internal */
export const CreateProjectEnvError$inboundSchema: z.ZodType<
  CreateProjectEnvError,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.string(),
  message: types.string(),
  key: types.optional(types.string()),
  envVarId: types.optional(types.string()),
  envVarKey: types.optional(types.string()),
  action: types.optional(types.string()),
  link: types.optional(types.string()),
  value: types.optional(
    smartUnion([types.string(), z.array(CreateProjectEnvValue2$inboundSchema)]),
  ),
  gitBranch: types.optional(types.string()),
  target: types.optional(
    smartUnion([
      z.array(CreateProjectEnvTargetProjects1$inboundSchema),
      CreateProjectEnvTargetProjectsResponse2$inboundSchema,
    ]),
  ),
  project: types.optional(types.string()),
});

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

/** @internal */
export const CreateProjectEnvFailed$inboundSchema: z.ZodType<
  CreateProjectEnvFailed,
  z.ZodTypeDef,
  unknown
> = z.object({
  error: z.lazy(() => CreateProjectEnvError$inboundSchema),
});

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

/** @internal */
export const CreateProjectEnvResponseBody$inboundSchema: z.ZodType<
  CreateProjectEnvResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  created: smartUnion([
    z.lazy(() => Created1$inboundSchema),
    z.array(z.lazy(() => Created2$inboundSchema)),
  ]),
  failed: z.array(z.lazy(() => CreateProjectEnvFailed$inboundSchema)),
});

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