/*
 * 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 { ACLAction, ACLAction$inboundSchema } from "./aclaction.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export type UploadProjectAvatarRequest = {
  /**
   * The unique project identifier or the project name.
   */
  idOrName: string;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
  requestBody?:
    | ReadableStream<Uint8Array>
    | Blob
    | ArrayBuffer
    | Uint8Array
    | undefined;
};

export type UploadProjectAvatarAnalytics = {
  id: string;
  canceledAt?: number | null | undefined;
  disabledAt: number;
  enabledAt: number;
  paidAt?: number | undefined;
  sampleRatePercent?: number | null | undefined;
  spendLimitInDollars?: number | null | undefined;
};

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

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

export type UploadProjectAvatarEnvId = string | UploadProjectAvatarEnvId2;

export type UploadProjectAvatarAws = {
  subnetIds: Array<string>;
  securityGroupId?: string | undefined;
};

export type UploadProjectAvatarConnectConfigurations = {
  envId: string | UploadProjectAvatarEnvId2;
  connectConfigurationId: string;
  dc?: string | undefined;
  passive: boolean;
  buildsEnabled: boolean;
  aws?: UploadProjectAvatarAws | undefined;
  createdAt: number;
  updatedAt: number;
};

/**
 * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
 */
export const UploadProjectAvatarSource = {
  Api: "api",
} as const;
/**
 * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
 */
export type UploadProjectAvatarSource = ClosedEnum<
  typeof UploadProjectAvatarSource
>;

export type UploadProjectAvatarDefinitions = {
  /**
   * The hostname that should be used.
   */
  host: string;
  /**
   * The path that should be called for the cronjob.
   */
  path: string;
  /**
   * The cron expression.
   */
  schedule: string;
  /**
   * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
   */
  source?: UploadProjectAvatarSource | undefined;
  /**
   * A human-readable description of what this cron job does.
   */
  description?: string | undefined;
  /**
   * Whether the host was inferred from the production deployment URL rather than explicitly provided.
   */
  hostInferred?: boolean | undefined;
};

export type UploadProjectAvatarCrons = {
  /**
   * The time the feature was enabled for this project. Note: It enables automatically with the first Deployment that outputs cronjobs.
   */
  enabledAt: number;
  /**
   * The time the feature was disabled for this project.
   */
  disabledAt: number | null;
  updatedAt: number;
  /**
   * The ID of the Deployment from which the definitions originated.
   */
  deploymentId: string | null;
  definitions: Array<UploadProjectAvatarDefinitions>;
};

export type UploadProjectAvatarDataCache = {
  userDisabled: boolean;
  storageSizeBytes?: number | null | undefined;
  unlimited?: boolean | undefined;
};

/**
 * Retention policies for deployments. These are enforced at the project level, but we also maintain an instance of this at the team level as a default policy that gets applied to new projects.
 */
export type UploadProjectAvatarDeploymentExpiration = {
  /**
   * Number of days to keep non-production deployments (mostly preview deployments) before soft deletion.
   */
  expirationDays?: number | undefined;
  /**
   * Number of days to keep production deployments before soft deletion.
   */
  expirationDaysProduction?: number | undefined;
  /**
   * Number of days to keep canceled deployments before soft deletion.
   */
  expirationDaysCanceled?: number | undefined;
  /**
   * Number of days to keep errored deployments before soft deletion.
   */
  expirationDaysErrored?: number | undefined;
  /**
   * Minimum number of production deployments to keep for this project, even if they are over the production expiration limit.
   */
  deploymentsToKeep?: number | undefined;
};

export type UploadProjectAvatarExpiration2 = {
  /**
   * Unix ms timestamp when the project was locked.
   */
  lockedAt: number;
  /**
   * userId of the actor that triggered the lock (system or admin).
   */
  lockedBy: string;
};

export type UploadProjectAvatarExpiration1 = {
  /**
   * Unix ms timestamp when the project is scheduled to expire.
   */
  expiresAt: number;
};

export type UploadProjectAvatarExpiration =
  | UploadProjectAvatarExpiration2
  | UploadProjectAvatarExpiration1;

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

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

export type UploadProjectAvatarTarget =
  | Array<UploadProjectAvatarTarget1>
  | UploadProjectAvatarTarget2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type UploadProjectAvatarContentHint =
  | UploadProjectAvatarContentHint1
  | UploadProjectAvatarContentHint2
  | UploadProjectAvatarContentHint3
  | UploadProjectAvatarContentHint4
  | UploadProjectAvatarContentHint5
  | UploadProjectAvatarContentHint6
  | UploadProjectAvatarContentHint7
  | UploadProjectAvatarContentHint8
  | UploadProjectAvatarContentHint9
  | UploadProjectAvatarContentHint10
  | UploadProjectAvatarContentHint11
  | UploadProjectAvatarContentHint12
  | UploadProjectAvatarContentHint13
  | UploadProjectAvatarContentHint14
  | UploadProjectAvatarContentHint15
  | UploadProjectAvatarContentHint16
  | UploadProjectAvatarContentHint17;

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

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

export type UploadProjectAvatarEnv = {
  target?:
    | Array<UploadProjectAvatarTarget1>
    | UploadProjectAvatarTarget2
    | undefined;
  type: UploadProjectAvatarType;
  /**
   * 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?:
    | UploadProjectAvatarContentHint1
    | UploadProjectAvatarContentHint2
    | UploadProjectAvatarContentHint3
    | UploadProjectAvatarContentHint4
    | UploadProjectAvatarContentHint5
    | UploadProjectAvatarContentHint6
    | UploadProjectAvatarContentHint7
    | UploadProjectAvatarContentHint8
    | UploadProjectAvatarContentHint9
    | UploadProjectAvatarContentHint10
    | UploadProjectAvatarContentHint11
    | UploadProjectAvatarContentHint12
    | UploadProjectAvatarContentHint13
    | UploadProjectAvatarContentHint14
    | UploadProjectAvatarContentHint15
    | UploadProjectAvatarContentHint16
    | UploadProjectAvatarContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | UploadProjectAvatarInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

/**
 * The type of environment (production, preview, or development)
 */
export const UploadProjectAvatarProjectsType = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
/**
 * The type of environment (production, preview, or development)
 */
export type UploadProjectAvatarProjectsType = ClosedEnum<
  typeof UploadProjectAvatarProjectsType
>;

/**
 * The type of matching to perform
 */
export const UploadProjectAvatarProjectsResponse200Type = {
  EndsWith: "endsWith",
  Equals: "equals",
  StartsWith: "startsWith",
} as const;
/**
 * The type of matching to perform
 */
export type UploadProjectAvatarProjectsResponse200Type = ClosedEnum<
  typeof UploadProjectAvatarProjectsResponse200Type
>;

/**
 * Configuration for matching git branches to this environment
 */
export type UploadProjectAvatarBranchMatcher = {
  /**
   * The type of matching to perform
   */
  type: UploadProjectAvatarProjectsResponse200Type;
  /**
   * The pattern to match against branch names
   */
  pattern: string;
};

/**
 * A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
 */
export type UploadProjectAvatarVerification = {
  type: string;
  domain: string;
  value: string;
  reason: string;
};

/**
 * List of domains associated with this environment
 */
export type UploadProjectAvatarDomains = {
  name: string;
  apexName: string;
  projectId: string;
  redirect?: string | null | undefined;
  redirectStatusCode?: number | null | undefined;
  gitBranch?: string | null | undefined;
  customEnvironmentId?: string | null | undefined;
  updatedAt?: number | undefined;
  createdAt?: number | undefined;
  /**
   * `true` if the domain is verified for use with the project. If `false` it will not be used as an alias on this project until the challenge in `verification` is completed.
   */
  verified: boolean;
  /**
   * A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
   */
  verification?: Array<UploadProjectAvatarVerification> | undefined;
};

/**
 * Internal representation of a custom environment with all required properties
 */
export type UploadProjectAvatarCustomEnvironments = {
  /**
   * Unique identifier for the custom environment (format: env_*)
   */
  id: string;
  /**
   * URL-friendly name of the environment
   */
  slug: string;
  /**
   * The type of environment (production, preview, or development)
   */
  type: UploadProjectAvatarProjectsType;
  /**
   * Optional description of the environment's purpose
   */
  description?: string | undefined;
  /**
   * Configuration for matching git branches to this environment
   */
  branchMatcher?: UploadProjectAvatarBranchMatcher | undefined;
  /**
   * List of domains associated with this environment
   */
  domains?: Array<UploadProjectAvatarDomains> | undefined;
  /**
   * List of aliases for the current deployment
   */
  currentDeploymentAliases?: Array<string> | undefined;
  /**
   * Timestamp when the environment was created
   */
  createdAt: number;
  /**
   * Timestamp when the environment was last updated
   */
  updatedAt: number;
};

export const UploadProjectAvatarFramework = {
  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 UploadProjectAvatarFramework = ClosedEnum<
  typeof UploadProjectAvatarFramework
>;

/**
 * Service kind (Service.type). Omitted for schemas that do not define one.
 */
export const UploadProjectAvatarServiceType = {
  Cron: "cron",
  Job: "job",
  Web: "web",
  Worker: "worker",
} as const;
/**
 * Service kind (Service.type). Omitted for schemas that do not define one.
 */
export type UploadProjectAvatarServiceType = ClosedEnum<
  typeof UploadProjectAvatarServiceType
>;

/**
 * Framework slug, when the service has one (omitted otherwise).
 */
export const UploadProjectAvatarProjectsFramework = {
  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;
/**
 * Framework slug, when the service has one (omitted otherwise).
 */
export type UploadProjectAvatarProjectsFramework = ClosedEnum<
  typeof UploadProjectAvatarProjectsFramework
>;

export type UploadProjectAvatarServices = {
  /**
   * Service name from the deployment (Service.name).
   */
  serviceName: string;
  /**
   * Service kind (Service.type). Omitted for schemas that do not define one.
   */
  serviceType?: UploadProjectAvatarServiceType | undefined;
  /**
   * Framework slug, when the service has one (omitted otherwise).
   */
  framework?: UploadProjectAvatarProjectsFramework | undefined;
  /**
   * Generic runtime, e.g. 'node' | 'python' | 'go' | 'ruby' | 'rust' (Service.runtime). Omitted for static builds.
   */
  runtime?: string | undefined;
};

export type UploadProjectAvatarIpBuckets = {
  bucket: string;
  default?: boolean | undefined;
  supportUntil?: number | undefined;
};

export type UploadProjectAvatarLint = {
  targets: Array<string>;
};

export type UploadProjectAvatarTypecheck = {
  targets: Array<string>;
};

export type UploadProjectAvatarMfeConfigPresent = {
  targets: Array<string>;
};

export type UploadProjectAvatarJobs = {
  lint?: UploadProjectAvatarLint | undefined;
  typecheck?: UploadProjectAvatarTypecheck | undefined;
  mfeConfigPresent?: UploadProjectAvatarMfeConfigPresent | undefined;
};

export type UploadProjectAvatarAliasAssigned = number | boolean;

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

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

export type UploadProjectAvatarLatestDeployments = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<UploadProjectAvatarBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: UploadProjectAvatarCreator | 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 UploadProjectAvatarLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks =
  {
    createdAt?: number | undefined;
    id: string;
    name: string;
    ref: string;
    url: string;
  };

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

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

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

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

export type UploadProjectAvatarLink4 = {
  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<UploadProjectAvatarLinkProjectsResponse200DeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type UploadProjectAvatarLink3 = {
  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<UploadProjectAvatarLinkProjectsResponseDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type UploadProjectAvatarLink2 = {
  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<UploadProjectAvatarLinkProjectsDeployHooks>;
  gitCredentialId: string;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type UploadProjectAvatarLink1 = {
  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<UploadProjectAvatarLinkDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UploadProjectAvatarLink =
  | UploadProjectAvatarLink1
  | UploadProjectAvatarLink2
  | UploadProjectAvatarLink3
  | UploadProjectAvatarLink4
  | UploadProjectAvatarLink5
  | UploadProjectAvatarLink6;

export type UploadProjectAvatarMicrofrontends3 = {
  updatedAt: number;
  groupIds: Array<any>;
  enabled: false;
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UploadProjectAvatarMicrofrontends2 = {
  isDefaultApp?: false | undefined;
  /**
   * Whether observability data should be routed to this microfrontend project or a root project.
   */
  routeObservabilityToThisProject?: boolean | undefined;
  /**
   * Whether to add microfrontends routing to aliases. This means domains in this project will route as a microfrontend.
   */
  doNotRouteWithMicrofrontendsRouting?: boolean | undefined;
  /**
   * Timestamp when the microfrontends settings were last updated.
   */
  updatedAt: number;
  /**
   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
   */
  groupIds: Array<string>;
  /**
   * Whether microfrontends are enabled for this project.
   */
  enabled: true;
  /**
   * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
   */
  defaultRoute?: string | undefined;
  /**
   * Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
   */
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UploadProjectAvatarMicrofrontends1 = {
  isDefaultApp: true;
  /**
   * Timestamp when the microfrontends settings were last updated.
   */
  updatedAt: number;
  /**
   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
   */
  groupIds: Array<string>;
  /**
   * Whether microfrontends are enabled for this project.
   */
  enabled: true;
  /**
   * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
   */
  defaultRoute?: string | undefined;
  /**
   * Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
   */
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UploadProjectAvatarMicrofrontends =
  | UploadProjectAvatarMicrofrontends1
  | UploadProjectAvatarMicrofrontends2
  | UploadProjectAvatarMicrofrontends3;

export const UploadProjectAvatarNodeVersion = {
  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 UploadProjectAvatarNodeVersion = ClosedEnum<
  typeof UploadProjectAvatarNodeVersion
>;

export type UploadProjectAvatarPaths = {
  value: string;
};

export type UploadProjectAvatarOptionsAllowlist = {
  paths: Array<UploadProjectAvatarPaths>;
};

export type UploadProjectAvatarPasswordProtection = {};

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

export type UploadProjectAvatarPassport = {
  deploymentType: UploadProjectAvatarDeploymentType;
  connectorId: string;
};

export type UploadProjectAvatarSandboxUrls = {
  inheritDeploymentProtection?: boolean | undefined;
};

export type UploadProjectAvatarProtectionConfig = {
  sandboxUrls?: UploadProjectAvatarSandboxUrls | undefined;
};

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

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

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

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

export type UploadProjectAvatarBuildQueue = {
  configuration?: UploadProjectAvatarConfiguration | undefined;
};

export type UploadProjectAvatarResourceConfig = {
  elasticConcurrencyEnabled?: boolean | undefined;
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | UploadProjectAvatarFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  buildMachineType?: UploadProjectAvatarBuildMachineType | undefined;
  buildMachineSelection?: UploadProjectAvatarBuildMachineSelection | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: UploadProjectAvatarBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

/**
 * Description of why a project was rolled back, and by whom. Note that lastAliasRequest contains the from/to details of the rollback.
 */
export type UploadProjectAvatarRollbackDescription = {
  /**
   * The user who rolled back the project.
   */
  userId: string;
  /**
   * The username of the user who rolled back the project.
   */
  username: string;
  /**
   * User-supplied explanation of why they rolled back the project. Limited to 250 characters.
   */
  description: string;
  /**
   * Timestamp of when the rollback was requested.
   */
  createdAt: number;
};

/**
 * 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 UploadProjectAvatarStages = {
  /**
   * 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 UploadProjectAvatarRollingRelease = {
  /**
   * 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<UploadProjectAvatarStages> | 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 const UploadProjectAvatarProjectsFunctionDefaultMemoryType = {
  Performance: "performance",
  PerformanceXl: "performance_xl",
  Standard: "standard",
  StandardLegacy: "standard_legacy",
} as const;
export type UploadProjectAvatarProjectsFunctionDefaultMemoryType = ClosedEnum<
  typeof UploadProjectAvatarProjectsFunctionDefaultMemoryType
>;

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

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

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

export type UploadProjectAvatarProjectsBuildQueue = {
  configuration?: UploadProjectAvatarProjectsConfiguration | undefined;
};

export type UploadProjectAvatarDefaultResourceConfig = {
  elasticConcurrencyEnabled?: boolean | undefined;
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | UploadProjectAvatarProjectsFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  buildMachineType?: UploadProjectAvatarProjectsBuildMachineType | undefined;
  buildMachineSelection?:
    | UploadProjectAvatarProjectsBuildMachineSelection
    | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: UploadProjectAvatarProjectsBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

export type UploadProjectAvatarStaticIps = {
  builds: boolean;
  enabled: boolean;
  regions: Array<string>;
};

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

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

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

export type UploadProjectAvatarSsoProtection = {
  deploymentType: UploadProjectAvatarProjectsDeploymentType;
  cve55182MigrationAppliedFrom?:
    | UploadProjectAvatarCve55182MigrationAppliedFrom
    | null
    | undefined;
  april2026SecurityIncidentMigrationAppliedFrom?:
    | UploadProjectAvatarApril2026SecurityIncidentMigrationAppliedFrom
    | null
    | undefined;
};

export type UploadProjectAvatarProjectsAliasAssigned = number | boolean;

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

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

export type UploadProjectAvatarTargets = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<UploadProjectAvatarProjectsBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: UploadProjectAvatarProjectsCreator | 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 UploadProjectAvatarPermissions = {
  oauth2Connection?: Array<ACLAction> | undefined;
  user?: Array<ACLAction> | undefined;
  userConnection?: Array<ACLAction> | undefined;
  userMfaConfiguration?: Array<ACLAction> | undefined;
  userPreference?: Array<ACLAction> | undefined;
  userSudo?: Array<ACLAction> | undefined;
  webAuthn?: Array<ACLAction> | undefined;
  accessGroup?: Array<ACLAction> | undefined;
  agent?: Array<ACLAction> | undefined;
  aiGatewayRules?: Array<ACLAction> | undefined;
  aiGatewayUsage?: Array<ACLAction> | undefined;
  alerts?: Array<ACLAction> | undefined;
  alertRules?: Array<ACLAction> | undefined;
  aliasGlobal?: Array<ACLAction> | undefined;
  analyticsSampling?: Array<ACLAction> | undefined;
  analyticsUsage?: Array<ACLAction> | undefined;
  apiKey?: Array<ACLAction> | undefined;
  apiKeyAiGateway?: Array<ACLAction> | undefined;
  apiKeyOwnedBySelf?: Array<ACLAction> | undefined;
  oauth2Application?: Array<ACLAction> | undefined;
  vercelAppInstallation?: Array<ACLAction> | undefined;
  vercelAppInstallationRequest?: Array<ACLAction> | undefined;
  auditLog?: Array<ACLAction> | undefined;
  billingAddress?: Array<ACLAction> | undefined;
  billingInformation?: Array<ACLAction> | undefined;
  billingInvoice?: Array<ACLAction> | undefined;
  billingInvoiceEmailRecipient?: Array<ACLAction> | undefined;
  billingInvoiceLanguage?: Array<ACLAction> | undefined;
  billingPlan?: Array<ACLAction> | undefined;
  billingPurchaseOrder?: Array<ACLAction> | undefined;
  billingRefund?: Array<ACLAction> | undefined;
  billingTaxId?: Array<ACLAction> | undefined;
  blob?: Array<ACLAction> | undefined;
  blobStoreTokenSet?: Array<ACLAction> | undefined;
  budget?: Array<ACLAction> | undefined;
  cacheArtifact?: Array<ACLAction> | undefined;
  cacheArtifactUsageEvent?: Array<ACLAction> | undefined;
  codeChecks?: Array<ACLAction> | undefined;
  ciInvocations?: Array<ACLAction> | undefined;
  ciLogs?: Array<ACLAction> | undefined;
  concurrentBuilds?: Array<ACLAction> | undefined;
  connect?: Array<ACLAction> | undefined;
  connectConfiguration?: Array<ACLAction> | undefined;
  connexClient?: Array<ACLAction> | undefined;
  connexClientProject?: Array<ACLAction> | undefined;
  connexToken?: Array<ACLAction> | undefined;
  buildMachineDefault?: Array<ACLAction> | undefined;
  dataCacheBillingSettings?: Array<ACLAction> | undefined;
  defaultDeploymentProtection?: Array<ACLAction> | undefined;
  deploymentPolicy?: Array<ACLAction> | undefined;
  domain?: Array<ACLAction> | undefined;
  domainAcceptDelegation?: Array<ACLAction> | undefined;
  domainAuthCodes?: Array<ACLAction> | undefined;
  domainCertificate?: Array<ACLAction> | undefined;
  domainCheckConfig?: Array<ACLAction> | undefined;
  domainMove?: Array<ACLAction> | undefined;
  domainPurchase?: Array<ACLAction> | undefined;
  domainRecord?: Array<ACLAction> | undefined;
  domainTransferIn?: Array<ACLAction> | undefined;
  drain?: Array<ACLAction> | undefined;
  edgeConfig?: Array<ACLAction> | undefined;
  edgeConfigItem?: Array<ACLAction> | undefined;
  edgeConfigSchema?: Array<ACLAction> | undefined;
  edgeConfigToken?: Array<ACLAction> | undefined;
  endpointVerification?: Array<ACLAction> | undefined;
  event?: Array<ACLAction> | undefined;
  fileUpload?: Array<ACLAction> | undefined;
  flagsExplorerSubscription?: Array<ACLAction> | undefined;
  gitRepository?: Array<ACLAction> | undefined;
  imageOptimizationNewPrice?: Array<ACLAction> | undefined;
  integration?: Array<ACLAction> | undefined;
  integrationAccount?: Array<ACLAction> | undefined;
  integrationConfiguration?: Array<ACLAction> | undefined;
  integrationConfigurationProjects?: Array<ACLAction> | undefined;
  integrationConfigurationRole?: Array<ACLAction> | undefined;
  integrationConfigurationTransfer?: Array<ACLAction> | undefined;
  integrationDeploymentAction?: Array<ACLAction> | undefined;
  integrationEvent?: Array<ACLAction> | undefined;
  integrationLog?: Array<ACLAction> | undefined;
  integrationResource?: Array<ACLAction> | undefined;
  integrationResourceData?: Array<ACLAction> | undefined;
  integrationResourceReplCommand?: Array<ACLAction> | undefined;
  integrationResourceSecrets?: Array<ACLAction> | undefined;
  integrationSSOSession?: Array<ACLAction> | undefined;
  integrationStrict?: Array<ACLAction> | undefined;
  integrationStoreTokenSet?: Array<ACLAction> | undefined;
  integrationVercelConfigurationOverride?: Array<ACLAction> | undefined;
  integrationPullRequest?: Array<ACLAction> | undefined;
  ipBlocking?: Array<ACLAction> | undefined;
  jobGlobal?: Array<ACLAction> | undefined;
  kmsIssuer?: Array<ACLAction> | undefined;
  kmsProjectGrant?: Array<ACLAction> | undefined;
  logDrain?: Array<ACLAction> | undefined;
  marketplaceBillingData?: Array<ACLAction> | undefined;
  marketplaceExperimentationEdgeConfigData?: Array<ACLAction> | undefined;
  marketplaceExperimentationItem?: Array<ACLAction> | undefined;
  marketplaceInstallationMember?: Array<ACLAction> | undefined;
  marketplaceInvoice?: Array<ACLAction> | undefined;
  marketplaceSettings?: Array<ACLAction> | undefined;
  monitoring?: Array<ACLAction> | undefined;
  monitoringAlert?: Array<ACLAction> | undefined;
  monitoringChart?: Array<ACLAction> | undefined;
  monitoringQuery?: Array<ACLAction> | undefined;
  monitoringSettings?: Array<ACLAction> | undefined;
  notificationCustomerBudget?: Array<ACLAction> | undefined;
  notificationDeploymentFailed?: Array<ACLAction> | undefined;
  notificationDomainConfiguration?: Array<ACLAction> | undefined;
  notificationDomainExpire?: Array<ACLAction> | undefined;
  notificationDomainMoved?: Array<ACLAction> | undefined;
  notificationDomainPurchase?: Array<ACLAction> | undefined;
  notificationDomainRenewal?: Array<ACLAction> | undefined;
  notificationDomainTransfer?: Array<ACLAction> | undefined;
  notificationDomainUnverified?: Array<ACLAction> | undefined;
  notificationMonitoringAlert?: Array<ACLAction> | undefined;
  notificationPaymentFailed?: Array<ACLAction> | undefined;
  notificationPreferences?: Array<ACLAction> | undefined;
  notificationStatementOfReasons?: Array<ACLAction> | undefined;
  notificationUsageAlert?: Array<ACLAction> | undefined;
  oidcFederationPolicy?: Array<ACLAction> | undefined;
  observabilityConfiguration?: Array<ACLAction> | undefined;
  observabilityFunnel?: Array<ACLAction> | undefined;
  observabilityNotebook?: Array<ACLAction> | undefined;
  openTelemetryEndpoint?: Array<ACLAction> | undefined;
  ownEvent?: Array<ACLAction> | undefined;
  organization?: Array<ACLAction> | undefined;
  organizationDomain?: Array<ACLAction> | undefined;
  organizationTeam?: Array<ACLAction> | undefined;
  passwordProtectionInvoiceItem?: Array<ACLAction> | undefined;
  paymentMethod?: Array<ACLAction> | undefined;
  permissions?: Array<ACLAction> | undefined;
  postgres?: Array<ACLAction> | undefined;
  postgresStoreTokenSet?: Array<ACLAction> | undefined;
  previewDeploymentSuffix?: Array<ACLAction> | undefined;
  privateCloudAccount?: Array<ACLAction> | undefined;
  projectTransferIn?: Array<ACLAction> | undefined;
  proTrialOnboarding?: Array<ACLAction> | undefined;
  rateLimit?: Array<ACLAction> | undefined;
  redis?: Array<ACLAction> | undefined;
  redisStoreTokenSet?: Array<ACLAction> | undefined;
  remoteCaching?: Array<ACLAction> | undefined;
  repository?: Array<ACLAction> | undefined;
  samlConfig?: Array<ACLAction> | undefined;
  secret?: Array<ACLAction> | undefined;
  sensitiveEnvironmentVariablePolicy?: Array<ACLAction> | undefined;
  sharedEnvVars?: Array<ACLAction> | undefined;
  sharedEnvVarsProduction?: Array<ACLAction> | undefined;
  space?: Array<ACLAction> | undefined;
  spaceRun?: Array<ACLAction> | undefined;
  storeIsLocked?: Array<ACLAction> | undefined;
  storeTokenSetSensitive?: Array<ACLAction> | undefined;
  storeTransfer?: Array<ACLAction> | undefined;
  supportCase?: Array<ACLAction> | undefined;
  supportCaseComment?: Array<ACLAction> | undefined;
  team?: Array<ACLAction> | undefined;
  teamAccessRequest?: Array<ACLAction> | undefined;
  teamFellowMembership?: Array<ACLAction> | undefined;
  teamGitExclusivity?: Array<ACLAction> | undefined;
  teamInvite?: Array<ACLAction> | undefined;
  teamInviteCode?: Array<ACLAction> | undefined;
  teamInviteLink?: Array<ACLAction> | undefined;
  teamJoin?: Array<ACLAction> | undefined;
  teamMemberMfaStatus?: Array<ACLAction> | undefined;
  teamMicrofrontends?: Array<ACLAction> | undefined;
  teamOwnMembership?: Array<ACLAction> | undefined;
  teamOwnMembershipDisconnectSAML?: Array<ACLAction> | undefined;
  teamSudo?: Array<ACLAction> | undefined;
  teamTokenInvalidation?: Array<ACLAction> | undefined;
  token?: Array<ACLAction> | undefined;
  toolbarComment?: Array<ACLAction> | undefined;
  usage?: Array<ACLAction> | undefined;
  usageCycle?: Array<ACLAction> | undefined;
  vcrRepository?: Array<ACLAction> | undefined;
  vercelRun?: Array<ACLAction> | undefined;
  vpcPeeringConnection?: Array<ACLAction> | undefined;
  webAnalyticsPlan?: Array<ACLAction> | undefined;
  webhook?: Array<ACLAction> | undefined;
  webhookEvent?: Array<ACLAction> | undefined;
  aliasProject?: Array<ACLAction> | undefined;
  aliasProtectionBypass?: Array<ACLAction> | undefined;
  bulkRedirects?: Array<ACLAction> | undefined;
  buildMachine?: Array<ACLAction> | undefined;
  connectConfigurationLink?: Array<ACLAction> | undefined;
  dataCacheNamespace?: Array<ACLAction> | undefined;
  deployment?: Array<ACLAction> | undefined;
  deploymentBuildLogs?: Array<ACLAction> | undefined;
  deploymentCheck?: Array<ACLAction> | undefined;
  deploymentCheckPreview?: Array<ACLAction> | undefined;
  deploymentCheckReRunFromProductionBranch?: Array<ACLAction> | undefined;
  deploymentProductionGit?: Array<ACLAction> | undefined;
  deploymentV0?: Array<ACLAction> | undefined;
  deploymentPreview?: Array<ACLAction> | undefined;
  deploymentPrivate?: Array<ACLAction> | undefined;
  deploymentPromote?: Array<ACLAction> | undefined;
  deploymentRollback?: Array<ACLAction> | undefined;
  edgeCacheNamespace?: Array<ACLAction> | undefined;
  environments?: Array<ACLAction> | undefined;
  job?: Array<ACLAction> | undefined;
  logs?: Array<ACLAction> | undefined;
  logsPreset?: Array<ACLAction> | undefined;
  observabilityData?: Array<ACLAction> | undefined;
  onDemandBuild?: Array<ACLAction> | undefined;
  onDemandConcurrency?: Array<ACLAction> | undefined;
  optionsAllowlist?: Array<ACLAction> | undefined;
  passwordProtection?: Array<ACLAction> | undefined;
  privateLinkEndpoint?: Array<ACLAction> | undefined;
  productionAliasProtectionBypass?: Array<ACLAction> | undefined;
  project?: Array<ACLAction> | undefined;
  projectAccessGroup?: Array<ACLAction> | undefined;
  projectAnalyticsSampling?: Array<ACLAction> | undefined;
  projectAnalyticsUsage?: Array<ACLAction> | undefined;
  projectCheck?: Array<ACLAction> | undefined;
  projectCheckRun?: Array<ACLAction> | undefined;
  projectDeploymentExpiration?: Array<ACLAction> | undefined;
  projectDeploymentHook?: Array<ACLAction> | undefined;
  projectDeploymentProtectionStrict?: Array<ACLAction> | undefined;
  projectDomain?: Array<ACLAction> | undefined;
  projectDomainCheckConfig?: Array<ACLAction> | undefined;
  projectDomainMove?: Array<ACLAction> | undefined;
  projectEvent?: Array<ACLAction> | undefined;
  projectEnvVars?: Array<ACLAction> | undefined;
  projectEnvVarsProduction?: Array<ACLAction> | undefined;
  projectEnvVarsUnownedByIntegration?: Array<ACLAction> | undefined;
  projectFlags?: Array<ACLAction> | undefined;
  projectFlagsProduction?: Array<ACLAction> | undefined;
  projectFlagsSDKKey?: Array<ACLAction> | undefined;
  projectFromV0?: Array<ACLAction> | undefined;
  projectId?: Array<ACLAction> | undefined;
  projectIntegrationConfiguration?: Array<ACLAction> | undefined;
  projectLink?: Array<ACLAction> | undefined;
  projectMember?: Array<ACLAction> | undefined;
  projectMonitoring?: Array<ACLAction> | undefined;
  projectOIDCToken?: Array<ACLAction> | undefined;
  projectPermissions?: Array<ACLAction> | undefined;
  projectProductionBranch?: Array<ACLAction> | undefined;
  projectProtectionBypass?: Array<ACLAction> | undefined;
  projectRollingRelease?: Array<ACLAction> | undefined;
  projectRoutes?: Array<ACLAction> | undefined;
  projectSupportCase?: Array<ACLAction> | undefined;
  projectSupportCaseComment?: Array<ACLAction> | undefined;
  projectTier?: Array<ACLAction> | undefined;
  projectTransfer?: Array<ACLAction> | undefined;
  projectTransferOut?: Array<ACLAction> | undefined;
  projectUsage?: Array<ACLAction> | undefined;
  pageIntegrity?: Array<ACLAction> | undefined;
  seawallConfig?: Array<ACLAction> | undefined;
  securityPlusConfiguration?: Array<ACLAction> | undefined;
  shareableLinkStrict?: Array<ACLAction> | undefined;
  sharedEnvVarConnection?: Array<ACLAction> | undefined;
  skewProtection?: Array<ACLAction> | undefined;
  analytics?: Array<ACLAction> | undefined;
  trustedIps?: Array<ACLAction> | undefined;
  trustedSources?: Array<ACLAction> | undefined;
  v0Chat?: Array<ACLAction> | undefined;
  webAnalytics?: Array<ACLAction> | undefined;
};

export type UploadProjectAvatarLastRollbackTarget = {};

export const UploadProjectAvatarJobStatus = {
  Failed: "failed",
  InProgress: "in-progress",
  Pending: "pending",
  Skipped: "skipped",
  Succeeded: "succeeded",
} as const;
export type UploadProjectAvatarJobStatus = ClosedEnum<
  typeof UploadProjectAvatarJobStatus
>;

export const UploadProjectAvatarProjectsResponseType = {
  Promote: "promote",
  Rollback: "rollback",
} as const;
export type UploadProjectAvatarProjectsResponseType = ClosedEnum<
  typeof UploadProjectAvatarProjectsResponseType
>;

export type UploadProjectAvatarLastAliasRequest = {
  fromDeploymentId: string | null;
  toDeploymentId: string;
  /**
   * If rolling back from a rolling release, fromDeploymentId captures the "base" of that rolling release, and fromRollingReleaseId captures the "target" of that rolling release.
   */
  fromRollingReleaseId?: string | undefined;
  jobStatus: UploadProjectAvatarJobStatus;
  requestedAt: number;
  type: UploadProjectAvatarProjectsResponseType;
};

export type UploadProjectAvatarProtectionBypass2 = {
  createdAt: number;
  createdBy: string;
  scope: "automation-bypass";
  /**
   * When there was only one bypass, it was automatically set as an env var on deployments. With multiple bypasses, there is always one bypass that is selected as the default, and gets set as an env var on deployments. As this is a new field, undefined means that the bypass is the env var. If there are any automation bypasses, exactly one must be the env var.
   */
  isEnvVar?: boolean | undefined;
  /**
   * Optional note about the bypass to be displayed in the UI
   */
  note?: string | undefined;
};

export type UploadProjectAvatarProtectionBypass1 = {
  createdAt: number;
  createdBy: string;
  scope: "integration-automation-bypass";
  integrationId: string;
  configurationId: string;
};

export type UploadProjectAvatarProtectionBypass =
  | UploadProjectAvatarProtectionBypass1
  | UploadProjectAvatarProtectionBypass2;

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

export type UploadProjectAvatarTrustedIps2 = {
  deploymentType: UploadProjectAvatarTrustedIpsProjectsDeploymentType;
};

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

export type UploadProjectAvatarTrustedIpsAddresses = {
  value: string;
  note?: string | undefined;
};

export const UploadProjectAvatarTrustedIpsProtectionMode = {
  Additional: "additional",
  Exclusive: "exclusive",
} as const;
export type UploadProjectAvatarTrustedIpsProtectionMode = ClosedEnum<
  typeof UploadProjectAvatarTrustedIpsProtectionMode
>;

export type UploadProjectAvatarTrustedIps1 = {
  deploymentType: UploadProjectAvatarTrustedIpsDeploymentType;
  addresses: Array<UploadProjectAvatarTrustedIpsAddresses>;
  protectionMode: UploadProjectAvatarTrustedIpsProtectionMode;
};

export type UploadProjectAvatarTrustedIps =
  | UploadProjectAvatarTrustedIps1
  | UploadProjectAvatarTrustedIps2;

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

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

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

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

export type UploadProjectAvatarFrom =
  | UploadProjectAvatarFrom1
  | UploadProjectAvatarFrom2;

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

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

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

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

export type UploadProjectAvatarProjectsTo =
  | UploadProjectAvatarToProjects1
  | UploadProjectAvatarToProjects2;

/**
 * Optional overrides for the default same-env-by-slug matching. Provide explicit rules to allow cross-env access or presets.
 */
export type UploadProjectAvatarCustomAllow = {
  from: UploadProjectAvatarFrom1 | UploadProjectAvatarFrom2;
  to: UploadProjectAvatarToProjects1 | UploadProjectAvatarToProjects2;
};

export type UploadProjectAvatarProjects = {
  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<UploadProjectAvatarCustomAllow> | undefined;
};

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

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

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

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

export type UploadProjectAvatarTo =
  | UploadProjectAvatarTo1
  | UploadProjectAvatarTo2;

export type UploadProjectAvatarOidcProviders = {
  to: UploadProjectAvatarTo1 | UploadProjectAvatarTo2;
  label?: string | undefined;
  claims: { [k: string]: Array<string> };
};

export type UploadProjectAvatarTrustedSources = {
  projects?: { [k: string]: UploadProjectAvatarProjects } | undefined;
  oidcProviders?:
    | { [k: string]: Array<UploadProjectAvatarOidcProviders> }
    | undefined;
};

export type UploadProjectAvatarGitComments = {
  /**
   * 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 UploadProjectAvatarCreateDeployments = {
  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 UploadProjectAvatarCreateDeployments = ClosedEnum<
  typeof UploadProjectAvatarCreateDeployments
>;

/**
 * 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 UploadProjectAvatarConsolidatedGitCommitStatus = {
  /**
   * Whether consolidated commit status is enabled.
   */
  enabled: boolean;
  /**
   * Whether to propagate individual deployment failures to the consolidated status.
   */
  propagateFailures: boolean;
};

export type UploadProjectAvatarGitProviderOptions = {
  /**
   * 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: UploadProjectAvatarCreateDeployments;
  /**
   * 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?:
    | UploadProjectAvatarConsolidatedGitCommitStatus
    | undefined;
};

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

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

export type UploadProjectAvatarVercelRuleset = {
  active: boolean;
  action?:
    | UploadProjectAvatarProjectsResponse200ApplicationJSONResponseBodyAction
    | undefined;
};

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

/** @internal */
export type UploadProjectAvatarRequest$Outbound = {
  idOrName: string;
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody?:
    | ReadableStream<Uint8Array>
    | Blob
    | ArrayBuffer
    | Uint8Array
    | undefined;
};

/** @internal */
export const UploadProjectAvatarRequest$outboundSchema: z.ZodType<
  UploadProjectAvatarRequest$Outbound,
  z.ZodTypeDef,
  UploadProjectAvatarRequest
> = z.object({
  idOrName: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.union([
    z.instanceof(ReadableStream<Uint8Array>),
    z.instanceof(Blob),
    z.instanceof(ArrayBuffer),
    z.instanceof(Uint8Array),
  ]).optional(),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function uploadProjectAvatarRequestToJSON(
  uploadProjectAvatarRequest: UploadProjectAvatarRequest,
): string {
  return JSON.stringify(
    UploadProjectAvatarRequest$outboundSchema.parse(uploadProjectAvatarRequest),
  );
}

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarConnectConfigurations$inboundSchema: z.ZodType<
  UploadProjectAvatarConnectConfigurations,
  z.ZodTypeDef,
  unknown
> = z.object({
  envId: smartUnion([types.string(), UploadProjectAvatarEnvId2$inboundSchema]),
  connectConfigurationId: types.string(),
  dc: types.optional(types.string()),
  passive: types.boolean(),
  buildsEnabled: types.boolean(),
  aws: types.optional(z.lazy(() => UploadProjectAvatarAws$inboundSchema)),
  createdAt: types.number(),
  updatedAt: types.number(),
});

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

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

/** @internal */
export const UploadProjectAvatarDefinitions$inboundSchema: z.ZodType<
  UploadProjectAvatarDefinitions,
  z.ZodTypeDef,
  unknown
> = z.object({
  host: types.string(),
  path: types.string(),
  schedule: types.string(),
  source: types.optional(UploadProjectAvatarSource$inboundSchema),
  description: types.optional(types.string()),
  hostInferred: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarCrons$inboundSchema: z.ZodType<
  UploadProjectAvatarCrons,
  z.ZodTypeDef,
  unknown
> = z.object({
  enabledAt: types.number(),
  disabledAt: types.nullable(types.number()),
  updatedAt: types.number(),
  deploymentId: types.nullable(types.string()),
  definitions: z.array(
    z.lazy(() => UploadProjectAvatarDefinitions$inboundSchema),
  ),
});

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

/** @internal */
export const UploadProjectAvatarDataCache$inboundSchema: z.ZodType<
  UploadProjectAvatarDataCache,
  z.ZodTypeDef,
  unknown
> = z.object({
  userDisabled: types.boolean(),
  storageSizeBytes: z.nullable(types.number()).optional(),
  unlimited: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarDeploymentExpiration$inboundSchema: z.ZodType<
  UploadProjectAvatarDeploymentExpiration,
  z.ZodTypeDef,
  unknown
> = z.object({
  expirationDays: types.optional(types.number()),
  expirationDaysProduction: types.optional(types.number()),
  expirationDaysCanceled: types.optional(types.number()),
  expirationDaysErrored: types.optional(types.number()),
  deploymentsToKeep: types.optional(types.number()),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarContentHint$inboundSchema: z.ZodType<
  UploadProjectAvatarContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UploadProjectAvatarContentHint1$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint2$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint3$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint4$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint5$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint6$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint7$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint8$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint9$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint10$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint11$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint12$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint13$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint14$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint15$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint16$inboundSchema),
  z.lazy(() => UploadProjectAvatarContentHint17$inboundSchema),
]);

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

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

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

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

/** @internal */
export const UploadProjectAvatarEnv$inboundSchema: z.ZodType<
  UploadProjectAvatarEnv,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(UploadProjectAvatarTarget1$inboundSchema),
      UploadProjectAvatarTarget2$inboundSchema,
    ]),
  ),
  type: UploadProjectAvatarType$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(() => UploadProjectAvatarContentHint1$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint2$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint3$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint4$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint5$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint6$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint7$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint8$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint9$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint10$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint11$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint12$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint13$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint14$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint15$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint16$inboundSchema),
      z.lazy(() => UploadProjectAvatarContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => UploadProjectAvatarInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarVerification$inboundSchema: z.ZodType<
  UploadProjectAvatarVerification,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.string(),
  domain: types.string(),
  value: types.string(),
  reason: types.string(),
});

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

/** @internal */
export const UploadProjectAvatarDomains$inboundSchema: z.ZodType<
  UploadProjectAvatarDomains,
  z.ZodTypeDef,
  unknown
> = z.object({
  name: types.string(),
  apexName: types.string(),
  projectId: types.string(),
  redirect: z.nullable(types.string()).optional(),
  redirectStatusCode: z.nullable(types.number()).optional(),
  gitBranch: z.nullable(types.string()).optional(),
  customEnvironmentId: z.nullable(types.string()).optional(),
  updatedAt: types.optional(types.number()),
  createdAt: types.optional(types.number()),
  verified: types.boolean(),
  verification: types.optional(
    z.array(z.lazy(() => UploadProjectAvatarVerification$inboundSchema)),
  ),
});

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

/** @internal */
export const UploadProjectAvatarCustomEnvironments$inboundSchema: z.ZodType<
  UploadProjectAvatarCustomEnvironments,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  slug: types.string(),
  type: UploadProjectAvatarProjectsType$inboundSchema,
  description: types.optional(types.string()),
  branchMatcher: types.optional(
    z.lazy(() => UploadProjectAvatarBranchMatcher$inboundSchema),
  ),
  domains: types.optional(
    z.array(z.lazy(() => UploadProjectAvatarDomains$inboundSchema)),
  ),
  currentDeploymentAliases: types.optional(z.array(types.string())),
  createdAt: types.number(),
  updatedAt: types.number(),
});

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

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

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

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

/** @internal */
export const UploadProjectAvatarServices$inboundSchema: z.ZodType<
  UploadProjectAvatarServices,
  z.ZodTypeDef,
  unknown
> = z.object({
  serviceName: types.string(),
  serviceType: types.optional(UploadProjectAvatarServiceType$inboundSchema),
  framework: types.optional(UploadProjectAvatarProjectsFramework$inboundSchema),
  runtime: types.optional(types.string()),
});

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

/** @internal */
export const UploadProjectAvatarIpBuckets$inboundSchema: z.ZodType<
  UploadProjectAvatarIpBuckets,
  z.ZodTypeDef,
  unknown
> = z.object({
  bucket: types.string(),
  default: types.optional(types.boolean()),
  supportUntil: types.optional(types.number()),
});

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarJobs$inboundSchema: z.ZodType<
  UploadProjectAvatarJobs,
  z.ZodTypeDef,
  unknown
> = z.object({
  lint: types.optional(z.lazy(() => UploadProjectAvatarLint$inboundSchema)),
  typecheck: types.optional(
    z.lazy(() => UploadProjectAvatarTypecheck$inboundSchema),
  ),
  "mfe-config-present": types.optional(
    z.lazy(() => UploadProjectAvatarMfeConfigPresent$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "mfe-config-present": "mfeConfigPresent",
  });
});

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarLatestDeployments$inboundSchema: z.ZodType<
  UploadProjectAvatarLatestDeployments,
  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(() => UploadProjectAvatarBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UploadProjectAvatarCreator$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 uploadProjectAvatarLatestDeploymentsFromJSON(
  jsonString: string,
): SafeParseResult<UploadProjectAvatarLatestDeployments, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UploadProjectAvatarLatestDeployments$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UploadProjectAvatarLatestDeployments' from JSON`,
  );
}

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

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

/** @internal */
export const UploadProjectAvatarLink6$inboundSchema: z.ZodType<
  UploadProjectAvatarLink6,
  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(() =>
      UploadProjectAvatarLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const UploadProjectAvatarLink5$inboundSchema: z.ZodType<
  UploadProjectAvatarLink5,
  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(() =>
      UploadProjectAvatarLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const UploadProjectAvatarLink4$inboundSchema: z.ZodType<
  UploadProjectAvatarLink4,
  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(() =>
      UploadProjectAvatarLinkProjectsResponse200DeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const UploadProjectAvatarLink3$inboundSchema: z.ZodType<
  UploadProjectAvatarLink3,
  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(() =>
      UploadProjectAvatarLinkProjectsResponseDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const UploadProjectAvatarLink2$inboundSchema: z.ZodType<
  UploadProjectAvatarLink2,
  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(() => UploadProjectAvatarLinkProjectsDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const UploadProjectAvatarLink1$inboundSchema: z.ZodType<
  UploadProjectAvatarLink1,
  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(() => UploadProjectAvatarLinkDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UploadProjectAvatarLink$inboundSchema: z.ZodType<
  UploadProjectAvatarLink,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UploadProjectAvatarLink1$inboundSchema),
  z.lazy(() => UploadProjectAvatarLink2$inboundSchema),
  z.lazy(() => UploadProjectAvatarLink3$inboundSchema),
  z.lazy(() => UploadProjectAvatarLink4$inboundSchema),
  z.lazy(() => UploadProjectAvatarLink5$inboundSchema),
  z.lazy(() => UploadProjectAvatarLink6$inboundSchema),
]);

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

/** @internal */
export const UploadProjectAvatarMicrofrontends3$inboundSchema: z.ZodType<
  UploadProjectAvatarMicrofrontends3,
  z.ZodTypeDef,
  unknown
> = z.object({
  updatedAt: types.number(),
  groupIds: z.array(z.any()),
  enabled: types.literal(false),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarMicrofrontends2$inboundSchema: z.ZodType<
  UploadProjectAvatarMicrofrontends2,
  z.ZodTypeDef,
  unknown
> = z.object({
  isDefaultApp: types.optional(types.literal(false)),
  routeObservabilityToThisProject: types.optional(types.boolean()),
  doNotRouteWithMicrofrontendsRouting: types.optional(types.boolean()),
  updatedAt: types.number(),
  groupIds: z.array(types.string()),
  enabled: types.literal(true),
  defaultRoute: types.optional(types.string()),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarMicrofrontends1$inboundSchema: z.ZodType<
  UploadProjectAvatarMicrofrontends1,
  z.ZodTypeDef,
  unknown
> = z.object({
  isDefaultApp: types.literal(true),
  updatedAt: types.number(),
  groupIds: z.array(types.string()),
  enabled: types.literal(true),
  defaultRoute: types.optional(types.string()),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarMicrofrontends$inboundSchema: z.ZodType<
  UploadProjectAvatarMicrofrontends,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UploadProjectAvatarMicrofrontends1$inboundSchema),
  z.lazy(() => UploadProjectAvatarMicrofrontends2$inboundSchema),
  z.lazy(() => UploadProjectAvatarMicrofrontends3$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarProtectionConfig$inboundSchema: z.ZodType<
  UploadProjectAvatarProtectionConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  sandboxUrls: types.optional(
    z.lazy(() => UploadProjectAvatarSandboxUrls$inboundSchema),
  ),
});

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarResourceConfig$inboundSchema: z.ZodType<
  UploadProjectAvatarResourceConfig,
  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(
    UploadProjectAvatarFunctionDefaultMemoryType$inboundSchema,
  ),
  functionZeroConfigFailover: types.optional(types.boolean()),
  buildMachineType: types.optional(
    UploadProjectAvatarBuildMachineType$inboundSchema,
  ),
  buildMachineSelection: types.optional(
    UploadProjectAvatarBuildMachineSelection$inboundSchema,
  ),
  buildMachineElasticLastUpdated: types.optional(types.number()),
  isNSNBDisabled: types.optional(types.boolean()),
  buildQueue: types.optional(
    z.lazy(() => UploadProjectAvatarBuildQueue$inboundSchema),
  ),
  enableFunctionsBeta: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarRollbackDescription$inboundSchema: z.ZodType<
  UploadProjectAvatarRollbackDescription,
  z.ZodTypeDef,
  unknown
> = z.object({
  userId: types.string(),
  username: types.string(),
  description: types.string(),
  createdAt: types.number(),
});

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarDefaultResourceConfig$inboundSchema: z.ZodType<
  UploadProjectAvatarDefaultResourceConfig,
  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(
    UploadProjectAvatarProjectsFunctionDefaultMemoryType$inboundSchema,
  ),
  functionZeroConfigFailover: types.optional(types.boolean()),
  buildMachineType: types.optional(
    UploadProjectAvatarProjectsBuildMachineType$inboundSchema,
  ),
  buildMachineSelection: types.optional(
    UploadProjectAvatarProjectsBuildMachineSelection$inboundSchema,
  ),
  buildMachineElasticLastUpdated: types.optional(types.number()),
  isNSNBDisabled: types.optional(types.boolean()),
  buildQueue: types.optional(
    z.lazy(() => UploadProjectAvatarProjectsBuildQueue$inboundSchema),
  ),
  enableFunctionsBeta: types.optional(types.boolean()),
});

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

/** @internal */
export const UploadProjectAvatarStaticIps$inboundSchema: z.ZodType<
  UploadProjectAvatarStaticIps,
  z.ZodTypeDef,
  unknown
> = z.object({
  builds: types.boolean(),
  enabled: types.boolean(),
  regions: z.array(types.string()),
});

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

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

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

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

/** @internal */
export const UploadProjectAvatarSsoProtection$inboundSchema: z.ZodType<
  UploadProjectAvatarSsoProtection,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: UploadProjectAvatarProjectsDeploymentType$inboundSchema,
  cve55182MigrationAppliedFrom: z.nullable(
    UploadProjectAvatarCve55182MigrationAppliedFrom$inboundSchema,
  ).optional(),
  april2026SecurityIncidentMigrationAppliedFrom: z.nullable(
    UploadProjectAvatarApril2026SecurityIncidentMigrationAppliedFrom$inboundSchema,
  ).optional(),
});

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarTargets$inboundSchema: z.ZodType<
  UploadProjectAvatarTargets,
  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(() => UploadProjectAvatarProjectsBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UploadProjectAvatarProjectsCreator$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 uploadProjectAvatarTargetsFromJSON(
  jsonString: string,
): SafeParseResult<UploadProjectAvatarTargets, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UploadProjectAvatarTargets$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UploadProjectAvatarTargets' from JSON`,
  );
}

/** @internal */
export const UploadProjectAvatarPermissions$inboundSchema: z.ZodType<
  UploadProjectAvatarPermissions,
  z.ZodTypeDef,
  unknown
> = z.object({
  oauth2Connection: types.optional(z.array(ACLAction$inboundSchema)),
  user: types.optional(z.array(ACLAction$inboundSchema)),
  userConnection: types.optional(z.array(ACLAction$inboundSchema)),
  userMfaConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  userPreference: types.optional(z.array(ACLAction$inboundSchema)),
  userSudo: types.optional(z.array(ACLAction$inboundSchema)),
  webAuthn: types.optional(z.array(ACLAction$inboundSchema)),
  accessGroup: types.optional(z.array(ACLAction$inboundSchema)),
  agent: types.optional(z.array(ACLAction$inboundSchema)),
  aiGatewayRules: types.optional(z.array(ACLAction$inboundSchema)),
  aiGatewayUsage: types.optional(z.array(ACLAction$inboundSchema)),
  alerts: types.optional(z.array(ACLAction$inboundSchema)),
  alertRules: types.optional(z.array(ACLAction$inboundSchema)),
  aliasGlobal: types.optional(z.array(ACLAction$inboundSchema)),
  analyticsSampling: types.optional(z.array(ACLAction$inboundSchema)),
  analyticsUsage: types.optional(z.array(ACLAction$inboundSchema)),
  apiKey: types.optional(z.array(ACLAction$inboundSchema)),
  apiKeyAiGateway: types.optional(z.array(ACLAction$inboundSchema)),
  apiKeyOwnedBySelf: types.optional(z.array(ACLAction$inboundSchema)),
  oauth2Application: types.optional(z.array(ACLAction$inboundSchema)),
  vercelAppInstallation: types.optional(z.array(ACLAction$inboundSchema)),
  vercelAppInstallationRequest: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  auditLog: types.optional(z.array(ACLAction$inboundSchema)),
  billingAddress: types.optional(z.array(ACLAction$inboundSchema)),
  billingInformation: types.optional(z.array(ACLAction$inboundSchema)),
  billingInvoice: types.optional(z.array(ACLAction$inboundSchema)),
  billingInvoiceEmailRecipient: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  billingInvoiceLanguage: types.optional(z.array(ACLAction$inboundSchema)),
  billingPlan: types.optional(z.array(ACLAction$inboundSchema)),
  billingPurchaseOrder: types.optional(z.array(ACLAction$inboundSchema)),
  billingRefund: types.optional(z.array(ACLAction$inboundSchema)),
  billingTaxId: types.optional(z.array(ACLAction$inboundSchema)),
  blob: types.optional(z.array(ACLAction$inboundSchema)),
  blobStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  budget: types.optional(z.array(ACLAction$inboundSchema)),
  cacheArtifact: types.optional(z.array(ACLAction$inboundSchema)),
  cacheArtifactUsageEvent: types.optional(z.array(ACLAction$inboundSchema)),
  codeChecks: types.optional(z.array(ACLAction$inboundSchema)),
  ciInvocations: types.optional(z.array(ACLAction$inboundSchema)),
  ciLogs: types.optional(z.array(ACLAction$inboundSchema)),
  concurrentBuilds: types.optional(z.array(ACLAction$inboundSchema)),
  connect: types.optional(z.array(ACLAction$inboundSchema)),
  connectConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  connexClient: types.optional(z.array(ACLAction$inboundSchema)),
  connexClientProject: types.optional(z.array(ACLAction$inboundSchema)),
  connexToken: types.optional(z.array(ACLAction$inboundSchema)),
  buildMachineDefault: types.optional(z.array(ACLAction$inboundSchema)),
  dataCacheBillingSettings: types.optional(z.array(ACLAction$inboundSchema)),
  defaultDeploymentProtection: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPolicy: types.optional(z.array(ACLAction$inboundSchema)),
  domain: types.optional(z.array(ACLAction$inboundSchema)),
  domainAcceptDelegation: types.optional(z.array(ACLAction$inboundSchema)),
  domainAuthCodes: types.optional(z.array(ACLAction$inboundSchema)),
  domainCertificate: types.optional(z.array(ACLAction$inboundSchema)),
  domainCheckConfig: types.optional(z.array(ACLAction$inboundSchema)),
  domainMove: types.optional(z.array(ACLAction$inboundSchema)),
  domainPurchase: types.optional(z.array(ACLAction$inboundSchema)),
  domainRecord: types.optional(z.array(ACLAction$inboundSchema)),
  domainTransferIn: types.optional(z.array(ACLAction$inboundSchema)),
  drain: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfig: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigItem: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigSchema: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigToken: types.optional(z.array(ACLAction$inboundSchema)),
  endpointVerification: types.optional(z.array(ACLAction$inboundSchema)),
  event: types.optional(z.array(ACLAction$inboundSchema)),
  fileUpload: types.optional(z.array(ACLAction$inboundSchema)),
  flagsExplorerSubscription: types.optional(z.array(ACLAction$inboundSchema)),
  gitRepository: types.optional(z.array(ACLAction$inboundSchema)),
  imageOptimizationNewPrice: types.optional(z.array(ACLAction$inboundSchema)),
  integration: types.optional(z.array(ACLAction$inboundSchema)),
  integrationAccount: types.optional(z.array(ACLAction$inboundSchema)),
  integrationConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  integrationConfigurationProjects: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationConfigurationRole: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationConfigurationTransfer: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationDeploymentAction: types.optional(z.array(ACLAction$inboundSchema)),
  integrationEvent: types.optional(z.array(ACLAction$inboundSchema)),
  integrationLog: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResource: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResourceData: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResourceReplCommand: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationResourceSecrets: types.optional(z.array(ACLAction$inboundSchema)),
  integrationSSOSession: types.optional(z.array(ACLAction$inboundSchema)),
  integrationStrict: types.optional(z.array(ACLAction$inboundSchema)),
  integrationStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  integrationVercelConfigurationOverride: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationPullRequest: types.optional(z.array(ACLAction$inboundSchema)),
  ipBlocking: types.optional(z.array(ACLAction$inboundSchema)),
  jobGlobal: types.optional(z.array(ACLAction$inboundSchema)),
  kmsIssuer: types.optional(z.array(ACLAction$inboundSchema)),
  kmsProjectGrant: types.optional(z.array(ACLAction$inboundSchema)),
  logDrain: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceBillingData: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceExperimentationEdgeConfigData: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceExperimentationItem: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceInstallationMember: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceInvoice: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceSettings: types.optional(z.array(ACLAction$inboundSchema)),
  Monitoring: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringAlert: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringChart: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringQuery: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringSettings: types.optional(z.array(ACLAction$inboundSchema)),
  notificationCustomerBudget: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDeploymentFailed: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationDomainConfiguration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationDomainExpire: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainMoved: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainPurchase: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainRenewal: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainUnverified: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  NotificationMonitoringAlert: types.optional(z.array(ACLAction$inboundSchema)),
  notificationPaymentFailed: types.optional(z.array(ACLAction$inboundSchema)),
  notificationPreferences: types.optional(z.array(ACLAction$inboundSchema)),
  notificationStatementOfReasons: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationUsageAlert: types.optional(z.array(ACLAction$inboundSchema)),
  oidcFederationPolicy: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityFunnel: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityNotebook: types.optional(z.array(ACLAction$inboundSchema)),
  openTelemetryEndpoint: types.optional(z.array(ACLAction$inboundSchema)),
  ownEvent: types.optional(z.array(ACLAction$inboundSchema)),
  organization: types.optional(z.array(ACLAction$inboundSchema)),
  organizationDomain: types.optional(z.array(ACLAction$inboundSchema)),
  organizationTeam: types.optional(z.array(ACLAction$inboundSchema)),
  passwordProtectionInvoiceItem: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  paymentMethod: types.optional(z.array(ACLAction$inboundSchema)),
  permissions: types.optional(z.array(ACLAction$inboundSchema)),
  postgres: types.optional(z.array(ACLAction$inboundSchema)),
  postgresStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  previewDeploymentSuffix: types.optional(z.array(ACLAction$inboundSchema)),
  privateCloudAccount: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransferIn: types.optional(z.array(ACLAction$inboundSchema)),
  proTrialOnboarding: types.optional(z.array(ACLAction$inboundSchema)),
  rateLimit: types.optional(z.array(ACLAction$inboundSchema)),
  redis: types.optional(z.array(ACLAction$inboundSchema)),
  redisStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  remoteCaching: types.optional(z.array(ACLAction$inboundSchema)),
  repository: types.optional(z.array(ACLAction$inboundSchema)),
  samlConfig: types.optional(z.array(ACLAction$inboundSchema)),
  secret: types.optional(z.array(ACLAction$inboundSchema)),
  sensitiveEnvironmentVariablePolicy: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  sharedEnvVars: types.optional(z.array(ACLAction$inboundSchema)),
  sharedEnvVarsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  space: types.optional(z.array(ACLAction$inboundSchema)),
  spaceRun: types.optional(z.array(ACLAction$inboundSchema)),
  storeIsLocked: types.optional(z.array(ACLAction$inboundSchema)),
  storeTokenSetSensitive: types.optional(z.array(ACLAction$inboundSchema)),
  storeTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  supportCase: types.optional(z.array(ACLAction$inboundSchema)),
  supportCaseComment: types.optional(z.array(ACLAction$inboundSchema)),
  team: types.optional(z.array(ACLAction$inboundSchema)),
  teamAccessRequest: types.optional(z.array(ACLAction$inboundSchema)),
  teamFellowMembership: types.optional(z.array(ACLAction$inboundSchema)),
  teamGitExclusivity: types.optional(z.array(ACLAction$inboundSchema)),
  teamInvite: types.optional(z.array(ACLAction$inboundSchema)),
  teamInviteCode: types.optional(z.array(ACLAction$inboundSchema)),
  teamInviteLink: types.optional(z.array(ACLAction$inboundSchema)),
  teamJoin: types.optional(z.array(ACLAction$inboundSchema)),
  teamMemberMfaStatus: types.optional(z.array(ACLAction$inboundSchema)),
  teamMicrofrontends: types.optional(z.array(ACLAction$inboundSchema)),
  teamOwnMembership: types.optional(z.array(ACLAction$inboundSchema)),
  teamOwnMembershipDisconnectSAML: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  teamSudo: types.optional(z.array(ACLAction$inboundSchema)),
  teamTokenInvalidation: types.optional(z.array(ACLAction$inboundSchema)),
  token: types.optional(z.array(ACLAction$inboundSchema)),
  toolbarComment: types.optional(z.array(ACLAction$inboundSchema)),
  usage: types.optional(z.array(ACLAction$inboundSchema)),
  usageCycle: types.optional(z.array(ACLAction$inboundSchema)),
  vcrRepository: types.optional(z.array(ACLAction$inboundSchema)),
  vercelRun: types.optional(z.array(ACLAction$inboundSchema)),
  vpcPeeringConnection: types.optional(z.array(ACLAction$inboundSchema)),
  webAnalyticsPlan: types.optional(z.array(ACLAction$inboundSchema)),
  webhook: types.optional(z.array(ACLAction$inboundSchema)),
  "webhook-event": types.optional(z.array(ACLAction$inboundSchema)),
  aliasProject: types.optional(z.array(ACLAction$inboundSchema)),
  aliasProtectionBypass: types.optional(z.array(ACLAction$inboundSchema)),
  bulkRedirects: types.optional(z.array(ACLAction$inboundSchema)),
  buildMachine: types.optional(z.array(ACLAction$inboundSchema)),
  connectConfigurationLink: types.optional(z.array(ACLAction$inboundSchema)),
  dataCacheNamespace: types.optional(z.array(ACLAction$inboundSchema)),
  deployment: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentBuildLogs: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheck: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheckPreview: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheckReRunFromProductionBranch: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  deploymentProductionGit: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentV0: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPreview: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPrivate: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPromote: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentRollback: types.optional(z.array(ACLAction$inboundSchema)),
  edgeCacheNamespace: types.optional(z.array(ACLAction$inboundSchema)),
  environments: types.optional(z.array(ACLAction$inboundSchema)),
  job: types.optional(z.array(ACLAction$inboundSchema)),
  logs: types.optional(z.array(ACLAction$inboundSchema)),
  logsPreset: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityData: types.optional(z.array(ACLAction$inboundSchema)),
  onDemandBuild: types.optional(z.array(ACLAction$inboundSchema)),
  onDemandConcurrency: types.optional(z.array(ACLAction$inboundSchema)),
  optionsAllowlist: types.optional(z.array(ACLAction$inboundSchema)),
  passwordProtection: types.optional(z.array(ACLAction$inboundSchema)),
  privateLinkEndpoint: types.optional(z.array(ACLAction$inboundSchema)),
  productionAliasProtectionBypass: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  project: types.optional(z.array(ACLAction$inboundSchema)),
  projectAccessGroup: types.optional(z.array(ACLAction$inboundSchema)),
  projectAnalyticsSampling: types.optional(z.array(ACLAction$inboundSchema)),
  projectAnalyticsUsage: types.optional(z.array(ACLAction$inboundSchema)),
  projectCheck: types.optional(z.array(ACLAction$inboundSchema)),
  projectCheckRun: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentExpiration: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentHook: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentProtectionStrict: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectDomain: types.optional(z.array(ACLAction$inboundSchema)),
  projectDomainCheckConfig: types.optional(z.array(ACLAction$inboundSchema)),
  projectDomainMove: types.optional(z.array(ACLAction$inboundSchema)),
  projectEvent: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVars: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVarsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVarsUnownedByIntegration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectFlags: types.optional(z.array(ACLAction$inboundSchema)),
  projectFlagsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  projectFlagsSdkKey: types.optional(z.array(ACLAction$inboundSchema)),
  projectFromV0: types.optional(z.array(ACLAction$inboundSchema)),
  projectId: types.optional(z.array(ACLAction$inboundSchema)),
  projectIntegrationConfiguration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectLink: types.optional(z.array(ACLAction$inboundSchema)),
  projectMember: types.optional(z.array(ACLAction$inboundSchema)),
  projectMonitoring: types.optional(z.array(ACLAction$inboundSchema)),
  projectOIDCToken: types.optional(z.array(ACLAction$inboundSchema)),
  projectPermissions: types.optional(z.array(ACLAction$inboundSchema)),
  projectProductionBranch: types.optional(z.array(ACLAction$inboundSchema)),
  projectProtectionBypass: types.optional(z.array(ACLAction$inboundSchema)),
  projectRollingRelease: types.optional(z.array(ACLAction$inboundSchema)),
  projectRoutes: types.optional(z.array(ACLAction$inboundSchema)),
  projectSupportCase: types.optional(z.array(ACLAction$inboundSchema)),
  projectSupportCaseComment: types.optional(z.array(ACLAction$inboundSchema)),
  projectTier: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransferOut: types.optional(z.array(ACLAction$inboundSchema)),
  projectUsage: types.optional(z.array(ACLAction$inboundSchema)),
  pageIntegrity: types.optional(z.array(ACLAction$inboundSchema)),
  seawallConfig: types.optional(z.array(ACLAction$inboundSchema)),
  securityPlusConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  shareableLinkStrict: types.optional(z.array(ACLAction$inboundSchema)),
  sharedEnvVarConnection: types.optional(z.array(ACLAction$inboundSchema)),
  skewProtection: types.optional(z.array(ACLAction$inboundSchema)),
  analytics: types.optional(z.array(ACLAction$inboundSchema)),
  trustedIps: types.optional(z.array(ACLAction$inboundSchema)),
  trustedSources: types.optional(z.array(ACLAction$inboundSchema)),
  v0Chat: types.optional(z.array(ACLAction$inboundSchema)),
  webAnalytics: types.optional(z.array(ACLAction$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "Monitoring": "monitoring",
    "NotificationMonitoringAlert": "notificationMonitoringAlert",
    "webhook-event": "webhookEvent",
    "projectFlagsSdkKey": "projectFlagsSDKKey",
  });
});

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarLastAliasRequest$inboundSchema: z.ZodType<
  UploadProjectAvatarLastAliasRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  fromDeploymentId: types.nullable(types.string()),
  toDeploymentId: types.string(),
  fromRollingReleaseId: types.optional(types.string()),
  jobStatus: UploadProjectAvatarJobStatus$inboundSchema,
  requestedAt: types.number(),
  type: UploadProjectAvatarProjectsResponseType$inboundSchema,
});

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

/** @internal */
export const UploadProjectAvatarProtectionBypass2$inboundSchema: z.ZodType<
  UploadProjectAvatarProtectionBypass2,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.number(),
  createdBy: types.string(),
  scope: types.literal("automation-bypass"),
  isEnvVar: types.optional(types.boolean()),
  note: types.optional(types.string()),
});

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

/** @internal */
export const UploadProjectAvatarProtectionBypass1$inboundSchema: z.ZodType<
  UploadProjectAvatarProtectionBypass1,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.number(),
  createdBy: types.string(),
  scope: types.literal("integration-automation-bypass"),
  integrationId: types.string(),
  configurationId: types.string(),
});

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarTrustedIps1$inboundSchema: z.ZodType<
  UploadProjectAvatarTrustedIps1,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: UploadProjectAvatarTrustedIpsDeploymentType$inboundSchema,
  addresses: z.array(
    z.lazy(() => UploadProjectAvatarTrustedIpsAddresses$inboundSchema),
  ),
  protectionMode: UploadProjectAvatarTrustedIpsProtectionMode$inboundSchema,
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UploadProjectAvatarCustomAllow$inboundSchema: z.ZodType<
  UploadProjectAvatarCustomAllow,
  z.ZodTypeDef,
  unknown
> = z.object({
  from: smartUnion([
    z.lazy(() => UploadProjectAvatarFrom1$inboundSchema),
    z.lazy(() => UploadProjectAvatarFrom2$inboundSchema),
  ]),
  to: smartUnion([
    z.lazy(() => UploadProjectAvatarToProjects1$inboundSchema),
    z.lazy(() => UploadProjectAvatarToProjects2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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