/*
 * 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 {
  GetProjectsContentHint10,
  GetProjectsContentHint10$inboundSchema,
  GetProjectsContentHint11,
  GetProjectsContentHint11$inboundSchema,
  GetProjectsContentHint12,
  GetProjectsContentHint12$inboundSchema,
  GetProjectsContentHint13,
  GetProjectsContentHint13$inboundSchema,
  GetProjectsContentHint14,
  GetProjectsContentHint14$inboundSchema,
  GetProjectsContentHint15,
  GetProjectsContentHint15$inboundSchema,
  GetProjectsContentHint16,
  GetProjectsContentHint16$inboundSchema,
  GetProjectsContentHint17,
  GetProjectsContentHint17$inboundSchema,
  GetProjectsResponseBodyProjectsTarget,
  GetProjectsResponseBodyProjectsTarget$inboundSchema,
  GetProjectsResponseBodyType,
  GetProjectsResponseBodyType$inboundSchema,
} from "./getprojectscontenthint10.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

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

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

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

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

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

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

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

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

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

export type GetProjectsResponseBodyContentHint =
  | GetProjectsContentHint1
  | GetProjectsContentHint2
  | GetProjectsContentHint3
  | GetProjectsContentHint4
  | GetProjectsContentHint5
  | GetProjectsContentHint6
  | GetProjectsContentHint7
  | GetProjectsContentHint8
  | GetProjectsContentHint9
  | GetProjectsContentHint10
  | GetProjectsContentHint11
  | GetProjectsContentHint12
  | GetProjectsContentHint13
  | GetProjectsContentHint14
  | GetProjectsContentHint15
  | GetProjectsContentHint16
  | GetProjectsContentHint17;

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

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

export type ResponseBodyEnv = {
  target?: GetProjectsResponseBodyProjectsTarget | undefined;
  type: GetProjectsResponseBodyType;
  /**
   * 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?:
    | GetProjectsContentHint1
    | GetProjectsContentHint2
    | GetProjectsContentHint3
    | GetProjectsContentHint4
    | GetProjectsContentHint5
    | GetProjectsContentHint6
    | GetProjectsContentHint7
    | GetProjectsContentHint8
    | GetProjectsContentHint9
    | GetProjectsContentHint10
    | GetProjectsContentHint11
    | GetProjectsContentHint12
    | GetProjectsContentHint13
    | GetProjectsContentHint14
    | GetProjectsContentHint15
    | GetProjectsContentHint16
    | GetProjectsContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | GetProjectsResponseBodyInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

export const ResponseBodyFramework = {
  ActixWeb: "actix-web",
  Angular: "angular",
  Ash: "ash",
  Astro: "astro",
  Axum: "axum",
  Blitzjs: "blitzjs",
  Brunch: "brunch",
  Bun: "bun",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  Fastapi: "fastapi",
  Fasthtml: "fasthtml",
  Fastify: "fastify",
  Flask: "flask",
  Gatsby: "gatsby",
  Go: "go",
  Gridsome: "gridsome",
  H3: "h3",
  Hexo: "hexo",
  Hono: "hono",
  Hugo: "hugo",
  Hydrogen: "hydrogen",
  IonicAngular: "ionic-angular",
  IonicReact: "ionic-react",
  Jekyll: "jekyll",
  Koa: "koa",
  Mastra: "mastra",
  Middleman: "middleman",
  Nestjs: "nestjs",
  Nextjs: "nextjs",
  Nitro: "nitro",
  Node: "node",
  Nuxtjs: "nuxtjs",
  Parcel: "parcel",
  Polymer: "polymer",
  Preact: "preact",
  Python: "python",
  ReactRouter: "react-router",
  Redwoodjs: "redwoodjs",
  Remix: "remix",
  Ruby: "ruby",
  Rust: "rust",
  Saber: "saber",
  Sanity: "sanity",
  SanityV2: "sanity-v2",
  Sapper: "sapper",
  Scully: "scully",
  Services: "services",
  Solidstart: "solidstart",
  Solidstart1: "solidstart-1",
  Stencil: "stencil",
  Storybook: "storybook",
  Svelte: "svelte",
  Sveltekit: "sveltekit",
  Sveltekit1: "sveltekit-1",
  TanstackStart: "tanstack-start",
  Umijs: "umijs",
  Vite: "vite",
  Vitepress: "vitepress",
  Vue: "vue",
  Vuepress: "vuepress",
  Xmcp: "xmcp",
  Zola: "zola",
} as const;
export type ResponseBodyFramework = ClosedEnum<typeof ResponseBodyFramework>;

export type ResponseBodyAliasAssigned = number | boolean;

export type GetProjectsResponseBodyBuilds = {
  use: string;
  src?: string | undefined;
  dest?: string | undefined;
};

export type GetProjectsResponseBodyCreator = {
  email: string;
  githubLogin?: string | undefined;
  gitlabLogin?: string | undefined;
  uid: string;
  username: string;
};

export type ResponseBodyLatestDeployments = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<GetProjectsResponseBodyBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: GetProjectsResponseBodyCreator | null;
  deploymentHostname: string;
  name: string;
  forced?: boolean | undefined;
  id: string;
  meta?: { [k: string]: string } | undefined;
  plan: string;
  private: boolean;
  readyState: string;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: string;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

export type GetProjectsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks =
  {
    createdAt?: number | undefined;
    id: string;
    name: string;
    ref: string;
    url: string;
  };

export type GetProjectsLink6 = {
  org: string;
  repo: string;
  type: "vercel";
  createdAt?: number | undefined;
  deployHooks: Array<
    GetProjectsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetProjectsLinkProjectsResponse200ApplicationJSONDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type GetProjectsLink5 = {
  name: string;
  slug: string;
  owner: string;
  type: "bitbucket";
  uuid: string;
  workspaceUuid: string;
  createdAt?: number | undefined;
  deployHooks: Array<
    GetProjectsLinkProjectsResponse200ApplicationJSONDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetProjectsLinkProjectsResponse200DeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type GetProjectsLink4 = {
  projectId: string;
  projectName: string;
  projectNameWithNamespace: string;
  projectNamespace: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes. This is the id of the top level group that a namespace belongs to. Gitlab supports group nesting (up to 20 levels).
   */
  projectOwnerId?: number | undefined;
  projectUrl: string;
  type: "gitlab";
  createdAt?: number | undefined;
  deployHooks: Array<GetProjectsLinkProjectsResponse200DeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetProjectsLinkProjectsResponseDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type GetProjectsLink3 = {
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  repo?: string | undefined;
  repoId?: number | undefined;
  type: "github-custom-host";
  host: string;
  createdAt?: number | undefined;
  deployHooks: Array<GetProjectsLinkProjectsResponseDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetProjectsLinkProjectsDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type GetProjectsLink2 = {
  type: "github-limited";
  repo?: string | undefined;
  repoId?: number | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  deployHooks: Array<GetProjectsLinkProjectsDeployHooks>;
  gitCredentialId: string;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetProjectsLinkDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type GetProjectsLink1 = {
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  repo?: string | undefined;
  repoId?: number | undefined;
  type: "github";
  createdAt?: number | undefined;
  deployHooks: Array<GetProjectsLinkDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type ResponseBodyLink =
  | GetProjectsLink1
  | GetProjectsLink2
  | GetProjectsLink3
  | GetProjectsLink4
  | GetProjectsLink5
  | GetProjectsLink6;

export const GetProjectsResponseBodyNodeVersion = {
  TenDotX: "10.x",
  TwelveDotX: "12.x",
  FourteenDotX: "14.x",
  SixteenDotX: "16.x",
  EighteenDotX: "18.x",
  TwentyDotX: "20.x",
  TwentyTwoDotX: "22.x",
  TwentyFourDotX: "24.x",
  EightDot10DotX: "8.10.x",
} as const;
export type GetProjectsResponseBodyNodeVersion = ClosedEnum<
  typeof GetProjectsResponseBodyNodeVersion
>;

export type ResponseBodyPasswordProtection = {};

export const ResponseBodyDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type ResponseBodyDeploymentType = ClosedEnum<
  typeof ResponseBodyDeploymentType
>;

export type ResponseBodyPassport = {
  deploymentType: ResponseBodyDeploymentType;
  connectorId: string;
};

export const ResponseBodyFunctionDefaultMemoryType = {
  Performance: "performance",
  PerformanceXl: "performance_xl",
  Standard: "standard",
  StandardLegacy: "standard_legacy",
} as const;
export type ResponseBodyFunctionDefaultMemoryType = ClosedEnum<
  typeof ResponseBodyFunctionDefaultMemoryType
>;

export const ResponseBodyBuildMachineType = {
  Enhanced: "enhanced",
  Standard: "standard",
  Turbo: "turbo",
} as const;
export type ResponseBodyBuildMachineType = ClosedEnum<
  typeof ResponseBodyBuildMachineType
>;

export const ResponseBodyBuildMachineSelection = {
  Elastic: "elastic",
  Fixed: "fixed",
} as const;
export type ResponseBodyBuildMachineSelection = ClosedEnum<
  typeof ResponseBodyBuildMachineSelection
>;

export const GetProjectsResponseBodyConfiguration = {
  SkipNamespaceQueue: "SKIP_NAMESPACE_QUEUE",
  WaitForNamespaceQueue: "WAIT_FOR_NAMESPACE_QUEUE",
} as const;
export type GetProjectsResponseBodyConfiguration = ClosedEnum<
  typeof GetProjectsResponseBodyConfiguration
>;

export type ResponseBodyBuildQueue = {
  configuration?: GetProjectsResponseBodyConfiguration | undefined;
};

export type ResponseBodyResourceConfig = {
  elasticConcurrencyEnabled?: boolean | undefined;
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?: ResponseBodyFunctionDefaultMemoryType | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  buildMachineType?: ResponseBodyBuildMachineType | undefined;
  buildMachineSelection?: ResponseBodyBuildMachineSelection | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: ResponseBodyBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

/**
 * An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100.
 */
export type ResponseBodyStages = {
  /**
   * The percentage of traffic to serve to the canary deployment (0-100)
   */
  targetPercentage: number;
  /**
   * Whether or not this stage requires manual approval to proceed
   */
  requireApproval?: boolean | undefined;
  /**
   * Duration in minutes for automatic advancement to the next stage
   */
  duration?: number | undefined;
  /**
   * Whether to linearly shift traffic over the duration of this stage
   */
  linearShift?: boolean | undefined;
};

/**
 * Project-level rolling release configuration that defines how deployments should be gradually rolled out
 */
export type ResponseBodyRollingRelease = {
  /**
   * The environment that the release targets, currently only supports production. Adding in case we want to configure with alias groups or custom environments.
   */
  target: string;
  /**
   * An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100.
   */
  stages?: Array<ResponseBodyStages> | null | undefined;
  /**
   * Whether the request served by a canary deployment should return a header indicating a canary was served. Defaults to `false` when omitted.
   */
  canaryResponseHeader?: boolean | undefined;
};

export type ResponseBodySpeedInsights = {
  id: string;
  enabledAt?: number | undefined;
  disabledAt?: number | undefined;
  canceledAt?: number | undefined;
  hasData?: boolean | undefined;
  paidAt?: number | undefined;
};

export const GetProjectsResponseBodyDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type GetProjectsResponseBodyDeploymentType = ClosedEnum<
  typeof GetProjectsResponseBodyDeploymentType
>;

export const ResponseBodyCve55182MigrationAppliedFrom = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type ResponseBodyCve55182MigrationAppliedFrom = ClosedEnum<
  typeof ResponseBodyCve55182MigrationAppliedFrom
>;

export const ResponseBodyApril2026SecurityIncidentMigrationAppliedFrom = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type ResponseBodyApril2026SecurityIncidentMigrationAppliedFrom =
  ClosedEnum<typeof ResponseBodyApril2026SecurityIncidentMigrationAppliedFrom>;

export type ResponseBodySsoProtection = {
  deploymentType: GetProjectsResponseBodyDeploymentType;
  cve55182MigrationAppliedFrom?:
    | ResponseBodyCve55182MigrationAppliedFrom
    | null
    | undefined;
  april2026SecurityIncidentMigrationAppliedFrom?:
    | ResponseBodyApril2026SecurityIncidentMigrationAppliedFrom
    | null
    | undefined;
};

export type GetProjectsResponseBodyAliasAssigned = number | boolean;

export type GetProjectsResponseBodyProjectsBuilds = {
  use: string;
  src?: string | undefined;
  dest?: string | undefined;
};

export type GetProjectsResponseBodyProjectsCreator = {
  email: string;
  githubLogin?: string | undefined;
  gitlabLogin?: string | undefined;
  uid: string;
  username: string;
};

export type ResponseBodyTargets = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<GetProjectsResponseBodyProjectsBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: GetProjectsResponseBodyProjectsCreator | null;
  deploymentHostname: string;
  name: string;
  forced?: boolean | undefined;
  id: string;
  meta?: { [k: string]: string } | undefined;
  plan: string;
  private: boolean;
  readyState: string;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: string;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

export const GetProjectsFromProjectsPreset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsFromProjectsPreset = ClosedEnum<
  typeof GetProjectsFromProjectsPreset
>;

/**
 * The source envs on the trusted project that are allowed to access `to`.
 */
export type GetProjectsFrom2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: GetProjectsFromProjectsPreset;
};

export const GetProjectsFromPreset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsFromPreset = ClosedEnum<typeof GetProjectsFromPreset>;

/**
 * The source envs on the trusted project that are allowed to access `to`.
 */
export type GetProjectsFrom1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: GetProjectsFromPreset | undefined;
};

export type ResponseBodyFrom = GetProjectsFrom1 | GetProjectsFrom2;

export const GetProjectsToProjectsResponse200Preset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsToProjectsResponse200Preset = ClosedEnum<
  typeof GetProjectsToProjectsResponse200Preset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type GetProjectsToProjects2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: GetProjectsToProjectsResponse200Preset;
};

export const GetProjectsToProjectsResponsePreset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsToProjectsResponsePreset = ClosedEnum<
  typeof GetProjectsToProjectsResponsePreset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type GetProjectsToProjects1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: GetProjectsToProjectsResponsePreset | undefined;
};

export type GetProjectsResponseBodyTo =
  | GetProjectsToProjects1
  | GetProjectsToProjects2;

/**
 * Optional overrides for the default same-env-by-slug matching. Provide explicit rules to allow cross-env access or presets.
 */
export type ResponseBodyCustomAllow = {
  from: GetProjectsFrom1 | GetProjectsFrom2;
  to: GetProjectsToProjects1 | GetProjectsToProjects2;
};

export type GetProjectsResponseBodyProjectsProjects = {
  label?: string | undefined;
  /**
   * Optional overrides for the default same-env-by-slug matching. Provide explicit rules to allow cross-env access or presets.
   */
  customAllow?: Array<ResponseBodyCustomAllow> | undefined;
};

export const GetProjectsToProjectsPreset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsToProjectsPreset = ClosedEnum<
  typeof GetProjectsToProjectsPreset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type GetProjectsTo2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: GetProjectsToProjectsPreset;
};

export const GetProjectsToPreset = {
  AllCustom: "all-custom",
} as const;
export type GetProjectsToPreset = ClosedEnum<typeof GetProjectsToPreset>;

/**
 * The target envs on the current project that may be accessed.
 */
export type GetProjectsTo1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: GetProjectsToPreset | undefined;
};

export type ResponseBodyTo = GetProjectsTo1 | GetProjectsTo2;

export type ResponseBodyOidcProviders = {
  to: GetProjectsTo1 | GetProjectsTo2;
  label?: string | undefined;
  claims: { [k: string]: Array<string> };
};

export type ResponseBodyTrustedSources = {
  projects?:
    | { [k: string]: GetProjectsResponseBodyProjectsProjects }
    | undefined;
  oidcProviders?: { [k: string]: Array<ResponseBodyOidcProviders> } | undefined;
};

export type ResponseBodyGitComments = {
  /**
   * Whether the Vercel bot should comment on PRs
   */
  onPullRequest: boolean;
  /**
   * Whether the Vercel bot should comment on commits
   */
  onCommit: boolean;
};

/**
 * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
 */
export const ResponseBodyCreateDeployments = {
  Disabled: "disabled",
  Enabled: "enabled",
} as const;
/**
 * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
 */
export type ResponseBodyCreateDeployments = ClosedEnum<
  typeof ResponseBodyCreateDeployments
>;

/**
 * Configuration for consolidated git commit status reporting. When enabled, Vercel will post a single consolidated commit status instead of individual statuses for each deployment.
 */
export type ResponseBodyConsolidatedGitCommitStatus = {
  /**
   * Whether consolidated commit status is enabled.
   */
  enabled: boolean;
  /**
   * Whether to propagate individual deployment failures to the consolidated status.
   */
  propagateFailures: boolean;
};

export type ResponseBodyGitProviderOptions = {
  /**
   * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
   */
  createDeployments: ResponseBodyCreateDeployments;
  /**
   * Whether the Vercel bot should not automatically create GitHub repository-dispatch events on deployment events. https://vercel.com/docs/git/vercel-for-github#repository-dispatch-events - `true`: disable repository-dispatch events for this project (explicit override of the team setting). - `false`: enable repository-dispatch events for this project (explicit override of the team setting). - absent: inherit from `team.disableRepositoryDispatchEvents`.
   */
  disableRepositoryDispatchEvents?: boolean | undefined;
  /**
   * Whether the project requires commits to be signed & verified before deployments will be created. - `true`: require verified commits for this project (explicit override of the team setting). - `false`: do not require verified commits (explicit override of the team setting). - absent: inherit from `team.requireVerifiedCommits`.
   */
  requireVerifiedCommits?: boolean | undefined;
  /**
   * Whether Vercel should post commit statuses for this project. When omitted, commit statuses remain enabled.
   */
  gitCommitStatus?: boolean | undefined;
  /**
   * Configuration for consolidated git commit status reporting. When enabled, Vercel will post a single consolidated commit status instead of individual statuses for each deployment.
   */
  consolidatedGitCommitStatus?:
    | ResponseBodyConsolidatedGitCommitStatus
    | undefined;
};

export type ResponseBodyWebAnalytics = {
  id: string;
  disabledAt?: number | undefined;
  canceledAt?: number | undefined;
  enabledAt?: number | undefined;
  hasData?: true | undefined;
};

export type Src2 = {
  re?: string | undefined;
  eq?: string | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type Src = string | Src2;

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityType =
  {
    Cookie: "cookie",
    Environment: "environment",
    Header: "header",
    Host: "host",
    InitialRequestPath: "initial_request_path",
    IpAddress: "ip_address",
    Method: "method",
    Path: "path",
    Protocol: "protocol",
    Query: "query",
    Region: "region",
    Scheme: "scheme",
    TrustedSource: "trusted_source",
  } as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityType =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityType
  >;

export type GetProjectsValue2 = {
  re?: string | undefined;
  eq?: string | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type GetProjectsResponseBodyProjectsValue = string | GetProjectsValue2;

export type GetProjectsResponseBodyHas = {
  type: GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityType;
  key?: string | undefined;
  value?: string | GetProjectsValue2 | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1Type = {
  Cookie: "cookie",
  Environment: "environment",
  Header: "header",
  Host: "host",
  InitialRequestPath: "initial_request_path",
  IpAddress: "ip_address",
  Method: "method",
  Path: "path",
  Protocol: "protocol",
  Query: "query",
  Region: "region",
  Scheme: "scheme",
  TrustedSource: "trusted_source",
} as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1Type =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1Type
  >;

export type GetProjectsValueProjects2 = {
  re?: string | undefined;
  eq?: string | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type GetProjectsResponseBodyValue = string | GetProjectsValueProjects2;

export type GetProjectsResponseBodyMissing = {
  type: GetProjectsResponseBodyProjectsResponse200ApplicationJson1Type;
  key?: string | undefined;
  value?: string | GetProjectsValueProjects2 | undefined;
};

export const ResponseBodyHandle = {
  Finalize: "finalize",
  Init: "init",
} as const;
export type ResponseBodyHandle = ClosedEnum<typeof ResponseBodyHandle>;

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityAction =
  {
    Bypass: "bypass",
    Challenge: "challenge",
    Deny: "deny",
    Log: "log",
    RateLimit: "rate_limit",
    Redirect: "redirect",
  } as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityAction =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityAction
  >;

export const ResponseBodyAlgo = {
  FixedWindow: "fixed_window",
  TokenBucket: "token_bucket",
} as const;
export type ResponseBodyAlgo = ClosedEnum<typeof ResponseBodyAlgo>;

export type Erl = {
  algo: ResponseBodyAlgo;
  window: number;
  limit: number;
  keys: Array<string>;
};

export const GetProjectsLogHeadersProjectsResponse2002 = {
  Wildcard: "*",
} as const;
export type GetProjectsLogHeadersProjectsResponse2002 = ClosedEnum<
  typeof GetProjectsLogHeadersProjectsResponse2002
>;

export type GetProjectsResponseBodyProjectsResponseLogHeaders =
  | Array<string>
  | GetProjectsLogHeadersProjectsResponse2002;

export type GetProjectsResponseBodyMitigate = {
  action:
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityAction;
  ruleId: string;
  ttl?: number | undefined;
  erl?: Erl | undefined;
  logHeaders?:
    | Array<string>
    | GetProjectsLogHeadersProjectsResponse2002
    | undefined;
};

export type FirewallRoutes = {
  src?: string | Src2 | undefined;
  has?: Array<GetProjectsResponseBodyHas> | undefined;
  missing?: Array<GetProjectsResponseBodyMissing> | undefined;
  dest?: string | undefined;
  status?: number | undefined;
  handle?: ResponseBodyHandle | undefined;
  mitigate?: GetProjectsResponseBodyMitigate | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesAction =
  {
    Challenge: "challenge",
    Deny: "deny",
    Log: "log",
  } as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesAction =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesAction
  >;

export type ResponseBodyVercelRuleset = {
  active: boolean;
  action?:
    | GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesAction
    | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesTrafficSourcesAction =
  {
    Challenge: "challenge",
    Deny: "deny",
    Log: "log",
  } as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesTrafficSourcesAction =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesTrafficSourcesAction
  >;

export type ResponseBodyTrafficSources = {
  active: boolean;
  action?:
    | GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesTrafficSourcesAction
    | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200Action = {
  Challenge: "challenge",
  Deny: "deny",
  Log: "log",
} as const;
export type GetProjectsResponseBodyProjectsResponse200Action = ClosedEnum<
  typeof GetProjectsResponseBodyProjectsResponse200Action
>;

export type ResponseBodyBotFilter = {
  active: boolean;
  action?: GetProjectsResponseBodyProjectsResponse200Action | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200ApplicationJSONAction = {
  Challenge: "challenge",
  Deny: "deny",
  Log: "log",
} as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJSONAction =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJSONAction
  >;

export type ResponseBodyAiBots = {
  active: boolean;
  action?:
    | GetProjectsResponseBodyProjectsResponse200ApplicationJSONAction
    | undefined;
};

export const GetProjectsResponseBodyProjectsResponse200ApplicationJson1Action =
  {
    Challenge: "challenge",
    Deny: "deny",
    Log: "log",
  } as const;
export type GetProjectsResponseBodyProjectsResponse200ApplicationJson1Action =
  ClosedEnum<
    typeof GetProjectsResponseBodyProjectsResponse200ApplicationJson1Action
  >;

export type ResponseBodyOwasp = {
  active: boolean;
  action?:
    | GetProjectsResponseBodyProjectsResponse200ApplicationJson1Action
    | undefined;
};

export type ResponseBodyManagedRules = {
  vercelRuleset: ResponseBodyVercelRuleset;
  trafficSources: ResponseBodyTrafficSources;
  botFilter: ResponseBodyBotFilter;
  aiBots: ResponseBodyAiBots;
  owasp: ResponseBodyOwasp;
};

export const GetProjectsLogHeaders2 = {
  Wildcard: "*",
} as const;
export type GetProjectsLogHeaders2 = ClosedEnum<typeof GetProjectsLogHeaders2>;

export type ResponseBodyLogHeaders = Array<string> | GetProjectsLogHeaders2;

export type ResponseBodySecurityPlusMetadata = {
  updatedAt: number;
  /**
   * Timestamp when the feature was first enabled. Never changes after initial enablement.
   */
  firstEnabledAt?: number | undefined;
};

export type ResponseBodySecurity = {
  attackModeEnabled?: boolean | undefined;
  attackModeUpdatedAt?: number | undefined;
  firewallEnabled?: boolean | undefined;
  firewallUpdatedAt?: number | undefined;
  attackModeActiveUntil?: number | null | undefined;
  firewallConfigVersion?: number | undefined;
  firewallRoutes?: Array<FirewallRoutes> | undefined;
  firewallSeawallEnabled?: boolean | undefined;
  ja3Enabled?: boolean | undefined;
  ja4Enabled?: boolean | undefined;
  firewallBypassIps?: Array<string> | undefined;
  managedRules?: ResponseBodyManagedRules | null | undefined;
  botIdEnabled?: boolean | undefined;
  requestLogsKey?: Array<string> | undefined;
  logHeaders?: Array<string> | GetProjectsLogHeaders2 | undefined;
  securityPlus?: boolean | undefined;
  securityPlusMetadata?: ResponseBodySecurityPlusMetadata | undefined;
  /**
   * Whether Page Integrity is enabled for this project. Used by the metadata service to gate DynamoDB lookups against the page-integrity-inventory table.
   */
  pageIntegrityEnabled?: boolean | undefined;
};

/**
 * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
 */
export const ResponseBodyIssuerMode = {
  Global: "global",
  Team: "team",
} as const;
/**
 * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
 */
export type ResponseBodyIssuerMode = ClosedEnum<typeof ResponseBodyIssuerMode>;

export type ResponseBodyOidcTokenConfig = {
  /**
   * Whether or not to generate OpenID Connect JSON Web Tokens.
   */
  enabled?: boolean | undefined;
  /**
   * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
   */
  issuerMode?: ResponseBodyIssuerMode | undefined;
};

export type ResponseBodyHistory = {
  scanner: string;
  reason: string;
  by: string;
  byId: string;
  at: number;
};

export const GetProjectsResponseBodyProjectsResponseAction = {
  Blocked: "blocked",
} as const;
export type GetProjectsResponseBodyProjectsResponseAction = ClosedEnum<
  typeof GetProjectsResponseBodyProjectsResponseAction
>;

export type ResponseBodyBlock = {
  action: GetProjectsResponseBodyProjectsResponseAction;
  reason: string;
  statusCode: number;
  createdAt: number;
  caseId?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
  ineligibleForAppeal?: boolean | undefined;
  isCascading?: boolean | undefined;
};

export type GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseValue =
  {
    eq: string;
  };

export type GetProjectsHasProjectsResponse2002 = {
  type: "host";
  value:
    GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseValue;
};

export const GetProjectsHasProjectsResponse200Key = {
  XVercelIpCountry: "x-vercel-ip-country",
} as const;
export type GetProjectsHasProjectsResponse200Key = ClosedEnum<
  typeof GetProjectsHasProjectsResponse200Key
>;

export type GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1Value =
  {
    eq: string;
  };

export type GetProjectsHasProjectsResponse2001 = {
  type: "header";
  key: GetProjectsHasProjectsResponse200Key;
  value: GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1Value;
};

export type GetProjectsRouteProjectsHas =
  | GetProjectsHasProjectsResponse2001
  | GetProjectsHasProjectsResponse2002;

export const GetProjectsRouteProjectsAction = {
  BlockLegalCwc: "block_legal_cwc",
} as const;
export type GetProjectsRouteProjectsAction = ClosedEnum<
  typeof GetProjectsRouteProjectsAction
>;

export type GetProjectsRouteProjectsMitigate = {
  action: GetProjectsRouteProjectsAction;
};

export type GetProjectsRouteProjects2 = {
  has: Array<
    GetProjectsHasProjectsResponse2001 | GetProjectsHasProjectsResponse2002
  >;
  mitigate: GetProjectsRouteProjectsMitigate;
  src?: string | undefined;
};

export type GetProjectsRouteProjects1 = {
  src: string;
  status: number;
};

export type GetProjectsBlockHistoryProjectsRoute =
  | GetProjectsRouteProjects1
  | GetProjectsRouteProjects2;

export type GetProjectsBlockHistory4 = {
  action: "route-unblocked";
  route: GetProjectsRouteProjects1 | GetProjectsRouteProjects2;
  statusCode?: number | undefined;
  createdAt: number;
  caseId?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
  ineligibleForAppeal?: boolean | undefined;
  isCascading?: boolean | undefined;
};

export type GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistory3Value =
  {
    eq: string;
  };

export type GetProjectsHasProjectsResponse200ApplicationJson2 = {
  type: "host";
  value:
    GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistory3Value;
};

export const GetProjectsHasProjectsResponse200ApplicationJSONKey = {
  XVercelIpCountry: "x-vercel-ip-country",
} as const;
export type GetProjectsHasProjectsResponse200ApplicationJSONKey = ClosedEnum<
  typeof GetProjectsHasProjectsResponse200ApplicationJSONKey
>;

export type GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistoryValue =
  {
    eq: string;
  };

export type GetProjectsHasProjectsResponse200ApplicationJson1 = {
  type: "header";
  key: GetProjectsHasProjectsResponse200ApplicationJSONKey;
  value:
    GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistoryValue;
};

export type GetProjectsRouteHas =
  | GetProjectsHasProjectsResponse200ApplicationJson1
  | GetProjectsHasProjectsResponse200ApplicationJson2;

export const GetProjectsRouteAction = {
  BlockLegalCwc: "block_legal_cwc",
} as const;
export type GetProjectsRouteAction = ClosedEnum<typeof GetProjectsRouteAction>;

export type GetProjectsRouteMitigate = {
  action: GetProjectsRouteAction;
};

export type GetProjectsRoute2 = {
  has: Array<
    | GetProjectsHasProjectsResponse200ApplicationJson1
    | GetProjectsHasProjectsResponse200ApplicationJson2
  >;
  mitigate: GetProjectsRouteMitigate;
  src?: string | undefined;
};

export type GetProjectsRoute1 = {
  src: string;
  status: number;
};

export type GetProjectsBlockHistoryRoute =
  | GetProjectsRoute1
  | GetProjectsRoute2;

export type GetProjectsBlockHistory3 = {
  action: "route-blocked";
  route: GetProjectsRoute1 | GetProjectsRoute2;
  reason: string;
  createdAt: number;
  caseId?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
  ineligibleForAppeal?: boolean | undefined;
  isCascading?: boolean | undefined;
};

export type GetProjectsBlockHistory2 = {
  action: "unblocked";
  createdAt: number;
  caseId?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
  ineligibleForAppeal?: boolean | undefined;
  isCascading?: boolean | undefined;
};

export type GetProjectsBlockHistory1 = {
  action: "blocked";
  reason: string;
  statusCode: number;
  createdAt: number;
  caseId?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
  ineligibleForAppeal?: boolean | undefined;
  isCascading?: boolean | undefined;
};

export type ResponseBodyBlockHistory =
  | GetProjectsBlockHistory1
  | GetProjectsBlockHistory2
  | GetProjectsBlockHistory3
  | GetProjectsBlockHistory4;

export const GetProjectsResponseBodyAction = {
  AddDeploymentInterstitial: "add-deployment-interstitial",
  AddProjectInterstitial: "add-project-interstitial",
  RemoveDeploymentInterstitial: "remove-deployment-interstitial",
  RemoveProjectInterstitial: "remove-project-interstitial",
} as const;
export type GetProjectsResponseBodyAction = ClosedEnum<
  typeof GetProjectsResponseBodyAction
>;

export type ResponseBodyInterstitialHistory = {
  action: GetProjectsResponseBodyAction;
  createdAt: number;
  caseId?: string | undefined;
  reason?: string | undefined;
  actor?: string | undefined;
  comment?: string | undefined;
};

export type ResponseBodyAbuse = {
  scanner?: string | undefined;
  history: Array<ResponseBodyHistory>;
  updatedAt: number;
  block?: ResponseBodyBlock | undefined;
  blockHistory?:
    | Array<
      | GetProjectsBlockHistory1
      | GetProjectsBlockHistory2
      | GetProjectsBlockHistory3
      | GetProjectsBlockHistory4
    >
    | undefined;
  interstitial?: boolean | undefined;
  interstitialHistory?: Array<ResponseBodyInterstitialHistory> | undefined;
};

export type GetProjectsHasProjectsValue = {
  eq: string;
};

export type GetProjectsHas2 = {
  type: "host";
  value: GetProjectsHasProjectsValue;
};

export const GetProjectsHasKey = {
  XVercelIpCountry: "x-vercel-ip-country",
} as const;
export type GetProjectsHasKey = ClosedEnum<typeof GetProjectsHasKey>;

export type GetProjectsHasValue = {
  eq: string;
};

export type GetProjectsHas1 = {
  type: "header";
  key: GetProjectsHasKey;
  value: GetProjectsHasValue;
};

export type GetProjectsInternalRoutesHas = GetProjectsHas1 | GetProjectsHas2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetProjectsResponseBodyContentHint$inboundSchema: z.ZodType<
  GetProjectsResponseBodyContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsContentHint1$inboundSchema),
  z.lazy(() => GetProjectsContentHint2$inboundSchema),
  z.lazy(() => GetProjectsContentHint3$inboundSchema),
  z.lazy(() => GetProjectsContentHint4$inboundSchema),
  z.lazy(() => GetProjectsContentHint5$inboundSchema),
  z.lazy(() => GetProjectsContentHint6$inboundSchema),
  z.lazy(() => GetProjectsContentHint7$inboundSchema),
  z.lazy(() => GetProjectsContentHint8$inboundSchema),
  z.lazy(() => GetProjectsContentHint9$inboundSchema),
  GetProjectsContentHint10$inboundSchema,
  GetProjectsContentHint11$inboundSchema,
  GetProjectsContentHint12$inboundSchema,
  GetProjectsContentHint13$inboundSchema,
  GetProjectsContentHint14$inboundSchema,
  GetProjectsContentHint15$inboundSchema,
  GetProjectsContentHint16$inboundSchema,
  GetProjectsContentHint17$inboundSchema,
]);

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

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

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

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

/** @internal */
export const ResponseBodyEnv$inboundSchema: z.ZodType<
  ResponseBodyEnv,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(GetProjectsResponseBodyProjectsTarget$inboundSchema),
  type: GetProjectsResponseBodyType$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(() => GetProjectsContentHint1$inboundSchema),
      z.lazy(() => GetProjectsContentHint2$inboundSchema),
      z.lazy(() => GetProjectsContentHint3$inboundSchema),
      z.lazy(() => GetProjectsContentHint4$inboundSchema),
      z.lazy(() => GetProjectsContentHint5$inboundSchema),
      z.lazy(() => GetProjectsContentHint6$inboundSchema),
      z.lazy(() => GetProjectsContentHint7$inboundSchema),
      z.lazy(() => GetProjectsContentHint8$inboundSchema),
      z.lazy(() => GetProjectsContentHint9$inboundSchema),
      GetProjectsContentHint10$inboundSchema,
      GetProjectsContentHint11$inboundSchema,
      GetProjectsContentHint12$inboundSchema,
      GetProjectsContentHint13$inboundSchema,
      GetProjectsContentHint14$inboundSchema,
      GetProjectsContentHint15$inboundSchema,
      GetProjectsContentHint16$inboundSchema,
      GetProjectsContentHint17$inboundSchema,
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => GetProjectsResponseBodyInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

/** @internal */
export const ResponseBodyAliasAssigned$inboundSchema: z.ZodType<
  ResponseBodyAliasAssigned,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.number(), types.boolean()]);

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

/** @internal */
export const GetProjectsResponseBodyBuilds$inboundSchema: z.ZodType<
  GetProjectsResponseBodyBuilds,
  z.ZodTypeDef,
  unknown
> = z.object({
  use: types.string(),
  src: types.optional(types.string()),
  dest: types.optional(types.string()),
});

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

/** @internal */
export const GetProjectsResponseBodyCreator$inboundSchema: z.ZodType<
  GetProjectsResponseBodyCreator,
  z.ZodTypeDef,
  unknown
> = z.object({
  email: types.string(),
  githubLogin: types.optional(types.string()),
  gitlabLogin: types.optional(types.string()),
  uid: types.string(),
  username: types.string(),
});

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

/** @internal */
export const ResponseBodyLatestDeployments$inboundSchema: z.ZodType<
  ResponseBodyLatestDeployments,
  z.ZodTypeDef,
  unknown
> = z.object({
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  builds: types.optional(
    z.array(z.lazy(() => GetProjectsResponseBodyBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => GetProjectsResponseBodyCreator$inboundSchema),
  ),
  deploymentHostname: types.string(),
  name: types.string(),
  forced: types.optional(types.boolean()),
  id: types.string(),
  meta: types.optional(z.record(types.string())),
  plan: types.string(),
  private: types.boolean(),
  readyState: types.string(),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: types.string(),
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

/** @internal */
export const GetProjectsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema:
  z.ZodType<
    GetProjectsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const GetProjectsLink6$inboundSchema: z.ZodType<
  GetProjectsLink6,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repo: types.string(),
  type: types.literal("vercel"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      GetProjectsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetProjectsLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema:
  z.ZodType<
    GetProjectsLinkProjectsResponse200ApplicationJSONDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const GetProjectsLink5$inboundSchema: z.ZodType<
  GetProjectsLink5,
  z.ZodTypeDef,
  unknown
> = z.object({
  name: types.string(),
  slug: types.string(),
  owner: types.string(),
  type: types.literal("bitbucket"),
  uuid: types.string(),
  workspaceUuid: types.string(),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      GetProjectsLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetProjectsLinkProjectsResponse200DeployHooks$inboundSchema:
  z.ZodType<
    GetProjectsLinkProjectsResponse200DeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const GetProjectsLink4$inboundSchema: z.ZodType<
  GetProjectsLink4,
  z.ZodTypeDef,
  unknown
> = z.object({
  projectId: types.string(),
  projectName: types.string(),
  projectNameWithNamespace: types.string(),
  projectNamespace: types.string(),
  projectOwnerId: types.optional(types.number()),
  projectUrl: types.string(),
  type: types.literal("gitlab"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() => GetProjectsLinkProjectsResponse200DeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetProjectsLinkProjectsResponseDeployHooks$inboundSchema:
  z.ZodType<GetProjectsLinkProjectsResponseDeployHooks, z.ZodTypeDef, unknown> =
    z.object({
      createdAt: types.optional(types.number()),
      id: types.string(),
      name: types.string(),
      ref: types.string(),
      url: types.string(),
    });

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

/** @internal */
export const GetProjectsLink3$inboundSchema: z.ZodType<
  GetProjectsLink3,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  type: types.literal("github-custom-host"),
  host: types.string(),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() => GetProjectsLinkProjectsResponseDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetProjectsLinkProjectsDeployHooks$inboundSchema: z.ZodType<
  GetProjectsLinkProjectsDeployHooks,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.optional(types.number()),
  id: types.string(),
  name: types.string(),
  ref: types.string(),
  url: types.string(),
});

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

/** @internal */
export const GetProjectsLink2$inboundSchema: z.ZodType<
  GetProjectsLink2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("github-limited"),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() => GetProjectsLinkProjectsDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetProjectsLinkDeployHooks$inboundSchema: z.ZodType<
  GetProjectsLinkDeployHooks,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.optional(types.number()),
  id: types.string(),
  name: types.string(),
  ref: types.string(),
  url: types.string(),
});

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

/** @internal */
export const GetProjectsLink1$inboundSchema: z.ZodType<
  GetProjectsLink1,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  type: types.literal("github"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(z.lazy(() => GetProjectsLinkDeployHooks$inboundSchema)),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const ResponseBodyLink$inboundSchema: z.ZodType<
  ResponseBodyLink,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsLink1$inboundSchema),
  z.lazy(() => GetProjectsLink2$inboundSchema),
  z.lazy(() => GetProjectsLink3$inboundSchema),
  z.lazy(() => GetProjectsLink4$inboundSchema),
  z.lazy(() => GetProjectsLink5$inboundSchema),
  z.lazy(() => GetProjectsLink6$inboundSchema),
]);

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

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

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

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

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

/** @internal */
export const ResponseBodyPassport$inboundSchema: z.ZodType<
  ResponseBodyPassport,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: ResponseBodyDeploymentType$inboundSchema,
  connectorId: types.string(),
});

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

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

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

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

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

/** @internal */
export const ResponseBodyBuildQueue$inboundSchema: z.ZodType<
  ResponseBodyBuildQueue,
  z.ZodTypeDef,
  unknown
> = z.object({
  configuration: types.optional(
    GetProjectsResponseBodyConfiguration$inboundSchema,
  ),
});

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

/** @internal */
export const ResponseBodyResourceConfig$inboundSchema: z.ZodType<
  ResponseBodyResourceConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  elasticConcurrencyEnabled: types.optional(types.boolean()),
  fluid: types.optional(types.boolean()),
  functionDefaultRegions: z.array(types.string()),
  functionDefaultTimeout: types.optional(types.number()),
  functionDefaultMemoryType: types.optional(
    ResponseBodyFunctionDefaultMemoryType$inboundSchema,
  ),
  functionZeroConfigFailover: types.optional(types.boolean()),
  buildMachineType: types.optional(ResponseBodyBuildMachineType$inboundSchema),
  buildMachineSelection: types.optional(
    ResponseBodyBuildMachineSelection$inboundSchema,
  ),
  buildMachineElasticLastUpdated: types.optional(types.number()),
  isNSNBDisabled: types.optional(types.boolean()),
  buildQueue: types.optional(
    z.lazy(() => ResponseBodyBuildQueue$inboundSchema),
  ),
  enableFunctionsBeta: types.optional(types.boolean()),
});

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

/** @internal */
export const ResponseBodyStages$inboundSchema: z.ZodType<
  ResponseBodyStages,
  z.ZodTypeDef,
  unknown
> = z.object({
  targetPercentage: types.number(),
  requireApproval: types.optional(types.boolean()),
  duration: types.optional(types.number()),
  linearShift: types.optional(types.boolean()),
});

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

/** @internal */
export const ResponseBodyRollingRelease$inboundSchema: z.ZodType<
  ResponseBodyRollingRelease,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.string(),
  stages: z.nullable(z.array(z.lazy(() => ResponseBodyStages$inboundSchema)))
    .optional(),
  canaryResponseHeader: types.optional(types.boolean()),
});

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

/** @internal */
export const ResponseBodySpeedInsights$inboundSchema: z.ZodType<
  ResponseBodySpeedInsights,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  enabledAt: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  canceledAt: types.optional(types.number()),
  hasData: types.optional(types.boolean()),
  paidAt: types.optional(types.number()),
});

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

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

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

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

/** @internal */
export const ResponseBodySsoProtection$inboundSchema: z.ZodType<
  ResponseBodySsoProtection,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: GetProjectsResponseBodyDeploymentType$inboundSchema,
  cve55182MigrationAppliedFrom: z.nullable(
    ResponseBodyCve55182MigrationAppliedFrom$inboundSchema,
  ).optional(),
  april2026SecurityIncidentMigrationAppliedFrom: z.nullable(
    ResponseBodyApril2026SecurityIncidentMigrationAppliedFrom$inboundSchema,
  ).optional(),
});

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

/** @internal */
export const GetProjectsResponseBodyAliasAssigned$inboundSchema: z.ZodType<
  GetProjectsResponseBodyAliasAssigned,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.number(), types.boolean()]);

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

/** @internal */
export const GetProjectsResponseBodyProjectsBuilds$inboundSchema: z.ZodType<
  GetProjectsResponseBodyProjectsBuilds,
  z.ZodTypeDef,
  unknown
> = z.object({
  use: types.string(),
  src: types.optional(types.string()),
  dest: types.optional(types.string()),
});

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

/** @internal */
export const GetProjectsResponseBodyProjectsCreator$inboundSchema: z.ZodType<
  GetProjectsResponseBodyProjectsCreator,
  z.ZodTypeDef,
  unknown
> = z.object({
  email: types.string(),
  githubLogin: types.optional(types.string()),
  gitlabLogin: types.optional(types.string()),
  uid: types.string(),
  username: types.string(),
});

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

/** @internal */
export const ResponseBodyTargets$inboundSchema: z.ZodType<
  ResponseBodyTargets,
  z.ZodTypeDef,
  unknown
> = z.object({
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  builds: types.optional(
    z.array(z.lazy(() => GetProjectsResponseBodyProjectsBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => GetProjectsResponseBodyProjectsCreator$inboundSchema),
  ),
  deploymentHostname: types.string(),
  name: types.string(),
  forced: types.optional(types.boolean()),
  id: types.string(),
  meta: types.optional(z.record(types.string())),
  plan: types.string(),
  private: types.boolean(),
  readyState: types.string(),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: types.string(),
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

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

/** @internal */
export const GetProjectsFrom2$inboundSchema: z.ZodType<
  GetProjectsFrom2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: GetProjectsFromProjectsPreset$inboundSchema,
});

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

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

/** @internal */
export const GetProjectsFrom1$inboundSchema: z.ZodType<
  GetProjectsFrom1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(GetProjectsFromPreset$inboundSchema),
});

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

/** @internal */
export const ResponseBodyFrom$inboundSchema: z.ZodType<
  ResponseBodyFrom,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetProjectsFrom1$inboundSchema),
  z.lazy(() => GetProjectsFrom2$inboundSchema),
]);

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

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

/** @internal */
export const GetProjectsToProjects2$inboundSchema: z.ZodType<
  GetProjectsToProjects2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: GetProjectsToProjectsResponse200Preset$inboundSchema,
});

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

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

/** @internal */
export const GetProjectsToProjects1$inboundSchema: z.ZodType<
  GetProjectsToProjects1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(GetProjectsToProjectsResponsePreset$inboundSchema),
});

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

/** @internal */
export const GetProjectsResponseBodyTo$inboundSchema: z.ZodType<
  GetProjectsResponseBodyTo,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetProjectsToProjects1$inboundSchema),
  z.lazy(() => GetProjectsToProjects2$inboundSchema),
]);

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

/** @internal */
export const ResponseBodyCustomAllow$inboundSchema: z.ZodType<
  ResponseBodyCustomAllow,
  z.ZodTypeDef,
  unknown
> = z.object({
  from: smartUnion([
    z.lazy(() => GetProjectsFrom1$inboundSchema),
    z.lazy(() => GetProjectsFrom2$inboundSchema),
  ]),
  to: smartUnion([
    z.lazy(() => GetProjectsToProjects1$inboundSchema),
    z.lazy(() => GetProjectsToProjects2$inboundSchema),
  ]),
});

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

/** @internal */
export const GetProjectsResponseBodyProjectsProjects$inboundSchema: z.ZodType<
  GetProjectsResponseBodyProjectsProjects,
  z.ZodTypeDef,
  unknown
> = z.object({
  label: types.optional(types.string()),
  customAllow: types.optional(
    z.array(z.lazy(() => ResponseBodyCustomAllow$inboundSchema)),
  ),
});

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

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

/** @internal */
export const GetProjectsTo2$inboundSchema: z.ZodType<
  GetProjectsTo2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: GetProjectsToProjectsPreset$inboundSchema,
});

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

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

/** @internal */
export const GetProjectsTo1$inboundSchema: z.ZodType<
  GetProjectsTo1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(GetProjectsToPreset$inboundSchema),
});

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

/** @internal */
export const ResponseBodyTo$inboundSchema: z.ZodType<
  ResponseBodyTo,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetProjectsTo1$inboundSchema),
  z.lazy(() => GetProjectsTo2$inboundSchema),
]);

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

/** @internal */
export const ResponseBodyOidcProviders$inboundSchema: z.ZodType<
  ResponseBodyOidcProviders,
  z.ZodTypeDef,
  unknown
> = z.object({
  to: smartUnion([
    z.lazy(() => GetProjectsTo1$inboundSchema),
    z.lazy(() => GetProjectsTo2$inboundSchema),
  ]),
  label: types.optional(types.string()),
  claims: z.record(z.array(types.string())),
});

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

/** @internal */
export const ResponseBodyTrustedSources$inboundSchema: z.ZodType<
  ResponseBodyTrustedSources,
  z.ZodTypeDef,
  unknown
> = z.object({
  projects: types.optional(
    z.record(
      z.lazy(() => GetProjectsResponseBodyProjectsProjects$inboundSchema),
    ),
  ),
  oidcProviders: types.optional(
    z.record(z.array(z.lazy(() => ResponseBodyOidcProviders$inboundSchema))),
  ),
});

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

/** @internal */
export const ResponseBodyGitComments$inboundSchema: z.ZodType<
  ResponseBodyGitComments,
  z.ZodTypeDef,
  unknown
> = z.object({
  onPullRequest: types.boolean(),
  onCommit: types.boolean(),
});

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

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

/** @internal */
export const ResponseBodyConsolidatedGitCommitStatus$inboundSchema: z.ZodType<
  ResponseBodyConsolidatedGitCommitStatus,
  z.ZodTypeDef,
  unknown
> = z.object({
  enabled: types.boolean(),
  propagateFailures: types.boolean(),
});

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

/** @internal */
export const ResponseBodyGitProviderOptions$inboundSchema: z.ZodType<
  ResponseBodyGitProviderOptions,
  z.ZodTypeDef,
  unknown
> = z.object({
  createDeployments: ResponseBodyCreateDeployments$inboundSchema,
  disableRepositoryDispatchEvents: types.optional(types.boolean()),
  requireVerifiedCommits: types.optional(types.boolean()),
  gitCommitStatus: types.optional(types.boolean()),
  consolidatedGitCommitStatus: types.optional(
    z.lazy(() => ResponseBodyConsolidatedGitCommitStatus$inboundSchema),
  ),
});

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

/** @internal */
export const ResponseBodyWebAnalytics$inboundSchema: z.ZodType<
  ResponseBodyWebAnalytics,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  disabledAt: types.optional(types.number()),
  canceledAt: types.optional(types.number()),
  enabledAt: types.optional(types.number()),
  hasData: types.optional(types.literal(true)),
});

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

/** @internal */
export const Src2$inboundSchema: z.ZodType<Src2, z.ZodTypeDef, unknown> = z
  .object({
    re: types.optional(types.string()),
    eq: types.optional(types.string()),
    neq: types.optional(types.string()),
    inc: types.optional(z.array(types.string())),
    ninc: types.optional(z.array(types.string())),
    pre: types.optional(types.string()),
    suf: types.optional(types.string()),
    gt: types.optional(types.number()),
    gte: types.optional(types.number()),
    lt: types.optional(types.number()),
    lte: types.optional(types.number()),
  });

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

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

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

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

/** @internal */
export const GetProjectsValue2$inboundSchema: z.ZodType<
  GetProjectsValue2,
  z.ZodTypeDef,
  unknown
> = z.object({
  re: types.optional(types.string()),
  eq: types.optional(types.string()),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

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

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

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

/** @internal */
export const GetProjectsResponseBodyHas$inboundSchema: z.ZodType<
  GetProjectsResponseBodyHas,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityType$inboundSchema,
  key: types.optional(types.string()),
  value: types.optional(
    smartUnion([types.string(), z.lazy(() => GetProjectsValue2$inboundSchema)]),
  ),
});

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

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

/** @internal */
export const GetProjectsValueProjects2$inboundSchema: z.ZodType<
  GetProjectsValueProjects2,
  z.ZodTypeDef,
  unknown
> = z.object({
  re: types.optional(types.string()),
  eq: types.optional(types.string()),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

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

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

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

/** @internal */
export const GetProjectsResponseBodyMissing$inboundSchema: z.ZodType<
  GetProjectsResponseBodyMissing,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1Type$inboundSchema,
  key: types.optional(types.string()),
  value: types.optional(
    smartUnion([
      types.string(),
      z.lazy(() => GetProjectsValueProjects2$inboundSchema),
    ]),
  ),
});

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

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

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

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

/** @internal */
export const Erl$inboundSchema: z.ZodType<Erl, z.ZodTypeDef, unknown> = z
  .object({
    algo: ResponseBodyAlgo$inboundSchema,
    window: types.number(),
    limit: types.number(),
    keys: z.array(types.string()),
  });

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

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

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

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

/** @internal */
export const GetProjectsResponseBodyMitigate$inboundSchema: z.ZodType<
  GetProjectsResponseBodyMitigate,
  z.ZodTypeDef,
  unknown
> = z.object({
  action:
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityAction$inboundSchema,
  rule_id: types.string(),
  ttl: types.optional(types.number()),
  erl: types.optional(z.lazy(() => Erl$inboundSchema)),
  log_headers: types.optional(
    smartUnion([
      z.array(types.string()),
      GetProjectsLogHeadersProjectsResponse2002$inboundSchema,
    ]),
  ),
}).transform((v) => {
  return remap$(v, {
    "rule_id": "ruleId",
    "log_headers": "logHeaders",
  });
});

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

/** @internal */
export const FirewallRoutes$inboundSchema: z.ZodType<
  FirewallRoutes,
  z.ZodTypeDef,
  unknown
> = z.object({
  src: types.optional(
    smartUnion([types.string(), z.lazy(() => Src2$inboundSchema)]),
  ),
  has: types.optional(
    z.array(z.lazy(() => GetProjectsResponseBodyHas$inboundSchema)),
  ),
  missing: types.optional(
    z.array(z.lazy(() => GetProjectsResponseBodyMissing$inboundSchema)),
  ),
  dest: types.optional(types.string()),
  status: types.optional(types.number()),
  handle: types.optional(ResponseBodyHandle$inboundSchema),
  mitigate: types.optional(
    z.lazy(() => GetProjectsResponseBodyMitigate$inboundSchema),
  ),
});

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

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

/** @internal */
export const ResponseBodyVercelRuleset$inboundSchema: z.ZodType<
  ResponseBodyVercelRuleset,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesAction$inboundSchema,
  ),
});

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

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

/** @internal */
export const ResponseBodyTrafficSources$inboundSchema: z.ZodType<
  ResponseBodyTrafficSources,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1SecurityManagedRulesTrafficSourcesAction$inboundSchema,
  ),
});

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

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

/** @internal */
export const ResponseBodyBotFilter$inboundSchema: z.ZodType<
  ResponseBodyBotFilter,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    GetProjectsResponseBodyProjectsResponse200Action$inboundSchema,
  ),
});

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

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

/** @internal */
export const ResponseBodyAiBots$inboundSchema: z.ZodType<
  ResponseBodyAiBots,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    GetProjectsResponseBodyProjectsResponse200ApplicationJSONAction$inboundSchema,
  ),
});

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

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

/** @internal */
export const ResponseBodyOwasp$inboundSchema: z.ZodType<
  ResponseBodyOwasp,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    GetProjectsResponseBodyProjectsResponse200ApplicationJson1Action$inboundSchema,
  ),
});

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

/** @internal */
export const ResponseBodyManagedRules$inboundSchema: z.ZodType<
  ResponseBodyManagedRules,
  z.ZodTypeDef,
  unknown
> = z.object({
  vercel_ruleset: z.lazy(() => ResponseBodyVercelRuleset$inboundSchema),
  traffic_sources: z.lazy(() => ResponseBodyTrafficSources$inboundSchema),
  bot_filter: z.lazy(() => ResponseBodyBotFilter$inboundSchema),
  ai_bots: z.lazy(() => ResponseBodyAiBots$inboundSchema),
  owasp: z.lazy(() => ResponseBodyOwasp$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "vercel_ruleset": "vercelRuleset",
    "traffic_sources": "trafficSources",
    "bot_filter": "botFilter",
    "ai_bots": "aiBots",
  });
});

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

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

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

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

/** @internal */
export const ResponseBodySecurityPlusMetadata$inboundSchema: z.ZodType<
  ResponseBodySecurityPlusMetadata,
  z.ZodTypeDef,
  unknown
> = z.object({
  updatedAt: types.number(),
  firstEnabledAt: types.optional(types.number()),
});

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

/** @internal */
export const ResponseBodySecurity$inboundSchema: z.ZodType<
  ResponseBodySecurity,
  z.ZodTypeDef,
  unknown
> = z.object({
  attackModeEnabled: types.optional(types.boolean()),
  attackModeUpdatedAt: types.optional(types.number()),
  firewallEnabled: types.optional(types.boolean()),
  firewallUpdatedAt: types.optional(types.number()),
  attackModeActiveUntil: z.nullable(types.number()).optional(),
  firewallConfigVersion: types.optional(types.number()),
  firewallRoutes: types.optional(
    z.array(z.lazy(() => FirewallRoutes$inboundSchema)),
  ),
  firewallSeawallEnabled: types.optional(types.boolean()),
  ja3Enabled: types.optional(types.boolean()),
  ja4Enabled: types.optional(types.boolean()),
  firewallBypassIps: types.optional(z.array(types.string())),
  managedRules: z.nullable(z.lazy(() => ResponseBodyManagedRules$inboundSchema))
    .optional(),
  botIdEnabled: types.optional(types.boolean()),
  requestLogsKey: types.optional(z.array(types.string())),
  log_headers: types.optional(
    smartUnion([z.array(types.string()), GetProjectsLogHeaders2$inboundSchema]),
  ),
  securityPlus: types.optional(types.boolean()),
  securityPlusMetadata: types.optional(
    z.lazy(() => ResponseBodySecurityPlusMetadata$inboundSchema),
  ),
  pageIntegrityEnabled: types.optional(types.boolean()),
}).transform((v) => {
  return remap$(v, {
    "log_headers": "logHeaders",
  });
});

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

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

/** @internal */
export const ResponseBodyOidcTokenConfig$inboundSchema: z.ZodType<
  ResponseBodyOidcTokenConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  enabled: types.optional(types.boolean()),
  issuerMode: types.optional(ResponseBodyIssuerMode$inboundSchema),
});

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

/** @internal */
export const ResponseBodyHistory$inboundSchema: z.ZodType<
  ResponseBodyHistory,
  z.ZodTypeDef,
  unknown
> = z.object({
  scanner: types.string(),
  reason: types.string(),
  by: types.string(),
  byId: types.string(),
  at: types.number(),
});

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

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

/** @internal */
export const ResponseBodyBlock$inboundSchema: z.ZodType<
  ResponseBodyBlock,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: GetProjectsResponseBodyProjectsResponseAction$inboundSchema,
  reason: types.string(),
  statusCode: types.number(),
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
  ineligibleForAppeal: types.optional(types.boolean()),
  isCascading: types.optional(types.boolean()),
});

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

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

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

/** @internal */
export const GetProjectsHasProjectsResponse2002$inboundSchema: z.ZodType<
  GetProjectsHasProjectsResponse2002,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("host"),
  value: z.lazy(() =>
    GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseValue$inboundSchema
  ),
});

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

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

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

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

/** @internal */
export const GetProjectsHasProjectsResponse2001$inboundSchema: z.ZodType<
  GetProjectsHasProjectsResponse2001,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("header"),
  key: GetProjectsHasProjectsResponse200Key$inboundSchema,
  value: z.lazy(() =>
    GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1Value$inboundSchema
  ),
});

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

/** @internal */
export const GetProjectsRouteProjectsHas$inboundSchema: z.ZodType<
  GetProjectsRouteProjectsHas,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsHasProjectsResponse2001$inboundSchema),
  z.lazy(() => GetProjectsHasProjectsResponse2002$inboundSchema),
]);

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

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

/** @internal */
export const GetProjectsRouteProjectsMitigate$inboundSchema: z.ZodType<
  GetProjectsRouteProjectsMitigate,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: GetProjectsRouteProjectsAction$inboundSchema,
});

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

/** @internal */
export const GetProjectsRouteProjects2$inboundSchema: z.ZodType<
  GetProjectsRouteProjects2,
  z.ZodTypeDef,
  unknown
> = z.object({
  has: z.array(
    z.union([
      z.lazy(() => GetProjectsHasProjectsResponse2001$inboundSchema),
      z.lazy(() => GetProjectsHasProjectsResponse2002$inboundSchema),
    ]),
  ),
  mitigate: z.lazy(() => GetProjectsRouteProjectsMitigate$inboundSchema),
  src: types.optional(types.string()),
});

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

/** @internal */
export const GetProjectsRouteProjects1$inboundSchema: z.ZodType<
  GetProjectsRouteProjects1,
  z.ZodTypeDef,
  unknown
> = z.object({
  src: types.string(),
  status: types.number(),
});

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

/** @internal */
export const GetProjectsBlockHistoryProjectsRoute$inboundSchema: z.ZodType<
  GetProjectsBlockHistoryProjectsRoute,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetProjectsRouteProjects1$inboundSchema),
  z.lazy(() => GetProjectsRouteProjects2$inboundSchema),
]);

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

/** @internal */
export const GetProjectsBlockHistory4$inboundSchema: z.ZodType<
  GetProjectsBlockHistory4,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: types.literal("route-unblocked"),
  route: smartUnion([
    z.lazy(() => GetProjectsRouteProjects1$inboundSchema),
    z.lazy(() => GetProjectsRouteProjects2$inboundSchema),
  ]),
  statusCode: types.optional(types.number()),
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
  ineligibleForAppeal: types.optional(types.boolean()),
  isCascading: types.optional(types.boolean()),
});

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

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

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

/** @internal */
export const GetProjectsHasProjectsResponse200ApplicationJson2$inboundSchema:
  z.ZodType<
    GetProjectsHasProjectsResponse200ApplicationJson2,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("host"),
    value: z.lazy(() =>
      GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistory3Value$inboundSchema
    ),
  });

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

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

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

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

/** @internal */
export const GetProjectsHasProjectsResponse200ApplicationJson1$inboundSchema:
  z.ZodType<
    GetProjectsHasProjectsResponse200ApplicationJson1,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type: types.literal("header"),
    key: GetProjectsHasProjectsResponse200ApplicationJSONKey$inboundSchema,
    value: z.lazy(() =>
      GetProjectsHasProjectsResponse200ApplicationJSONResponseBody1AbuseBlockHistoryValue$inboundSchema
    ),
  });

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

/** @internal */
export const GetProjectsRouteHas$inboundSchema: z.ZodType<
  GetProjectsRouteHas,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsHasProjectsResponse200ApplicationJson1$inboundSchema),
  z.lazy(() => GetProjectsHasProjectsResponse200ApplicationJson2$inboundSchema),
]);

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

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

/** @internal */
export const GetProjectsRouteMitigate$inboundSchema: z.ZodType<
  GetProjectsRouteMitigate,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: GetProjectsRouteAction$inboundSchema,
});

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

/** @internal */
export const GetProjectsRoute2$inboundSchema: z.ZodType<
  GetProjectsRoute2,
  z.ZodTypeDef,
  unknown
> = z.object({
  has: z.array(
    z.union([
      z.lazy(() =>
        GetProjectsHasProjectsResponse200ApplicationJson1$inboundSchema
      ),
      z.lazy(() =>
        GetProjectsHasProjectsResponse200ApplicationJson2$inboundSchema
      ),
    ]),
  ),
  mitigate: z.lazy(() => GetProjectsRouteMitigate$inboundSchema),
  src: types.optional(types.string()),
});

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

/** @internal */
export const GetProjectsRoute1$inboundSchema: z.ZodType<
  GetProjectsRoute1,
  z.ZodTypeDef,
  unknown
> = z.object({
  src: types.string(),
  status: types.number(),
});

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

/** @internal */
export const GetProjectsBlockHistoryRoute$inboundSchema: z.ZodType<
  GetProjectsBlockHistoryRoute,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetProjectsRoute1$inboundSchema),
  z.lazy(() => GetProjectsRoute2$inboundSchema),
]);

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

/** @internal */
export const GetProjectsBlockHistory3$inboundSchema: z.ZodType<
  GetProjectsBlockHistory3,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: types.literal("route-blocked"),
  route: smartUnion([
    z.lazy(() => GetProjectsRoute1$inboundSchema),
    z.lazy(() => GetProjectsRoute2$inboundSchema),
  ]),
  reason: types.string(),
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
  ineligibleForAppeal: types.optional(types.boolean()),
  isCascading: types.optional(types.boolean()),
});

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

/** @internal */
export const GetProjectsBlockHistory2$inboundSchema: z.ZodType<
  GetProjectsBlockHistory2,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: types.literal("unblocked"),
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
  ineligibleForAppeal: types.optional(types.boolean()),
  isCascading: types.optional(types.boolean()),
});

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

/** @internal */
export const GetProjectsBlockHistory1$inboundSchema: z.ZodType<
  GetProjectsBlockHistory1,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: types.literal("blocked"),
  reason: types.string(),
  statusCode: types.number(),
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
  ineligibleForAppeal: types.optional(types.boolean()),
  isCascading: types.optional(types.boolean()),
});

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

/** @internal */
export const ResponseBodyBlockHistory$inboundSchema: z.ZodType<
  ResponseBodyBlockHistory,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsBlockHistory1$inboundSchema),
  z.lazy(() => GetProjectsBlockHistory2$inboundSchema),
  z.lazy(() => GetProjectsBlockHistory3$inboundSchema),
  z.lazy(() => GetProjectsBlockHistory4$inboundSchema),
]);

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

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

/** @internal */
export const ResponseBodyInterstitialHistory$inboundSchema: z.ZodType<
  ResponseBodyInterstitialHistory,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: GetProjectsResponseBodyAction$inboundSchema,
  createdAt: types.number(),
  caseId: types.optional(types.string()),
  reason: types.optional(types.string()),
  actor: types.optional(types.string()),
  comment: types.optional(types.string()),
});

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

/** @internal */
export const ResponseBodyAbuse$inboundSchema: z.ZodType<
  ResponseBodyAbuse,
  z.ZodTypeDef,
  unknown
> = z.object({
  scanner: types.optional(types.string()),
  history: z.array(z.lazy(() => ResponseBodyHistory$inboundSchema)),
  updatedAt: types.number(),
  block: types.optional(z.lazy(() => ResponseBodyBlock$inboundSchema)),
  blockHistory: types.optional(
    z.array(z.union([
      z.lazy(() => GetProjectsBlockHistory1$inboundSchema),
      z.lazy(() =>
        GetProjectsBlockHistory2$inboundSchema
      ),
      z.lazy(() => GetProjectsBlockHistory3$inboundSchema),
      z.lazy(() => GetProjectsBlockHistory4$inboundSchema),
    ])),
  ),
  interstitial: types.optional(types.boolean()),
  interstitialHistory: types.optional(
    z.array(z.lazy(() => ResponseBodyInterstitialHistory$inboundSchema)),
  ),
});

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

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

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

/** @internal */
export const GetProjectsHas2$inboundSchema: z.ZodType<
  GetProjectsHas2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("host"),
  value: z.lazy(() => GetProjectsHasProjectsValue$inboundSchema),
});

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

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

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

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

/** @internal */
export const GetProjectsHas1$inboundSchema: z.ZodType<
  GetProjectsHas1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("header"),
  key: GetProjectsHasKey$inboundSchema,
  value: z.lazy(() => GetProjectsHasValue$inboundSchema),
});

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

/** @internal */
export const GetProjectsInternalRoutesHas$inboundSchema: z.ZodType<
  GetProjectsInternalRoutesHas,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetProjectsHas1$inboundSchema),
  z.lazy(() => GetProjectsHas2$inboundSchema),
]);

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