@vercel/sdk
Version:
<p align="center"> <a href="https://vercel.com"> <img src="https://assets.vercel.com/image/upload/v1588805858/repositories/vercel/logo.png" height="96"> <h3 align="center">Vercel</h3> </a> <p align="center">Develop. Preview. Ship.</p> </p>
2,103 lines • 97.7 kB
TypeScript
import * as z from "zod/v3";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
/**
* The framework that is being used for this project. When `null` is used no framework is selected
*/
export declare const UpdateProjectFramework: {
readonly Container: "container";
readonly Blitzjs: "blitzjs";
readonly Nextjs: "nextjs";
readonly Gatsby: "gatsby";
readonly Remix: "remix";
readonly ReactRouter: "react-router";
readonly Astro: "astro";
readonly Hexo: "hexo";
readonly Eleventy: "eleventy";
readonly Docusaurus2: "docusaurus-2";
readonly Docusaurus: "docusaurus";
readonly Preact: "preact";
readonly Solidstart1: "solidstart-1";
readonly Solidstart: "solidstart";
readonly Dojo: "dojo";
readonly Ember: "ember";
readonly Vue: "vue";
readonly Scully: "scully";
readonly IonicAngular: "ionic-angular";
readonly Angular: "angular";
readonly Polymer: "polymer";
readonly Svelte: "svelte";
readonly Sveltekit: "sveltekit";
readonly Sveltekit1: "sveltekit-1";
readonly IonicReact: "ionic-react";
readonly CreateReactApp: "create-react-app";
readonly Gridsome: "gridsome";
readonly Umijs: "umijs";
readonly Sapper: "sapper";
readonly Saber: "saber";
readonly Stencil: "stencil";
readonly Nuxtjs: "nuxtjs";
readonly Redwoodjs: "redwoodjs";
readonly Hugo: "hugo";
readonly Jekyll: "jekyll";
readonly Brunch: "brunch";
readonly Middleman: "middleman";
readonly Zola: "zola";
readonly Hydrogen: "hydrogen";
readonly Vite: "vite";
readonly TanstackStart: "tanstack-start";
readonly TanstackStartLovable: "tanstack-start-lovable";
readonly Vitepress: "vitepress";
readonly Vuepress: "vuepress";
readonly Parcel: "parcel";
readonly Fastapi: "fastapi";
readonly Flask: "flask";
readonly Fasthtml: "fasthtml";
readonly Django: "django";
readonly Ash: "ash";
readonly FactoryEve: "factory-eve";
readonly Eve: "eve";
readonly Sanity: "sanity";
readonly SanityV2: "sanity-v2";
readonly Storybook: "storybook";
readonly Nitro: "nitro";
readonly Hono: "hono";
readonly Express: "express";
readonly H3: "h3";
readonly Koa: "koa";
readonly Nestjs: "nestjs";
readonly Elysia: "elysia";
readonly Fastify: "fastify";
readonly Xmcp: "xmcp";
readonly Python: "python";
readonly Ruby: "ruby";
readonly Rust: "rust";
readonly Axum: "axum";
readonly ActixWeb: "actix-web";
readonly Bun: "bun";
readonly Node: "node";
readonly Go: "go";
readonly Services: "services";
readonly Mastra: "mastra";
};
/**
* The framework that is being used for this project. When `null` is used no framework is selected
*/
export type UpdateProjectFramework = ClosedEnum<typeof UpdateProjectFramework>;
export declare const UpdateProjectNodeVersion: {
readonly TwentyFourDotX: "24.x";
readonly TwentyTwoDotX: "22.x";
readonly TwentyDotX: "20.x";
readonly EighteenDotX: "18.x";
readonly SixteenDotX: "16.x";
readonly FourteenDotX: "14.x";
readonly TwelveDotX: "12.x";
readonly TenDotX: "10.x";
};
export type UpdateProjectNodeVersion = ClosedEnum<typeof UpdateProjectNodeVersion>;
export declare const UpdateProjectBuildMachineType: {
readonly Basic: "basic";
readonly Enhanced: "enhanced";
readonly Turbo: "turbo";
readonly Standard: "standard";
readonly Elastic: "elastic";
};
export type UpdateProjectBuildMachineType = ClosedEnum<typeof UpdateProjectBuildMachineType>;
export declare const UpdateProjectBuildMachineSelection: {
readonly Elastic: "elastic";
readonly Fixed: "fixed";
};
export type UpdateProjectBuildMachineSelection = ClosedEnum<typeof UpdateProjectBuildMachineSelection>;
export declare const UpdateProjectConfiguration: {
readonly SkipNamespaceQueue: "SKIP_NAMESPACE_QUEUE";
readonly WaitForNamespaceQueue: "WAIT_FOR_NAMESPACE_QUEUE";
};
export type UpdateProjectConfiguration = ClosedEnum<typeof UpdateProjectConfiguration>;
export type UpdateProjectBuildQueue = {
configuration?: UpdateProjectConfiguration | undefined;
};
export declare const UpdateProjectFunctionDefaultMemoryType: {
readonly StandardLegacy: "standard_legacy";
readonly Standard: "standard";
readonly Performance: "performance";
readonly PerformanceXl: "performance_xl";
};
export type UpdateProjectFunctionDefaultMemoryType = ClosedEnum<typeof UpdateProjectFunctionDefaultMemoryType>;
export declare const UpdateProjectBuildMachineElasticReason: {
readonly OomFailure: "oom-failure";
readonly EnospcFailure: "enospc-failure";
readonly BuildTimeoutFailure: "build-timeout-failure";
readonly BasicFloor: "basic-floor";
readonly HighPeakMemory: "high-peak-memory";
readonly SustainedHighCpu: "sustained-high-cpu";
readonly HighPeakDisk: "high-peak-disk";
readonly LongBuildDuration: "long-build-duration";
readonly ShortBuildDuration: "short-build-duration";
readonly EnterpriseFloor: "enterprise-floor";
};
export type UpdateProjectBuildMachineElasticReason = ClosedEnum<typeof UpdateProjectBuildMachineElasticReason>;
/**
* Specifies resource override configuration for the project
*/
export type UpdateProjectResourceConfig = {
buildMachineType?: UpdateProjectBuildMachineType | undefined;
buildMachineSelection?: UpdateProjectBuildMachineSelection | undefined;
buildQueue?: UpdateProjectBuildQueue | undefined;
fluid?: boolean | undefined;
/**
* The regions to deploy Vercel Functions to for this project
*/
functionDefaultRegions?: Array<string> | undefined;
functionDefaultTimeout?: number | undefined;
functionDefaultMemoryType?: UpdateProjectFunctionDefaultMemoryType | undefined;
/**
* Specifies whether Zero Config Failover is enabled for this project.
*/
functionZeroConfigFailover?: boolean | undefined;
elasticConcurrencyEnabled?: boolean | undefined;
buildMachineElasticLastUpdated?: number | undefined;
buildMachineElasticReason?: UpdateProjectBuildMachineElasticReason | undefined;
isNSNBDisabled?: boolean | undefined;
enableFunctionsBeta?: boolean | undefined;
};
/**
* Manage Static IPs for this project
*/
export type UpdateProjectStaticIps = {
/**
* Opt-in to Static IPs for this project
*/
enabled: boolean;
};
/**
* Environment to apply sampling to
*/
export declare const UpdateProjectEnv: {
readonly Production: "production";
readonly Preview: "preview";
};
/**
* Environment to apply sampling to
*/
export type UpdateProjectEnv = ClosedEnum<typeof UpdateProjectEnv>;
/**
* Tracing destination this rule applies to. Derived server-side when project tracing is computed; accepted here so a computed config can round-trip through this endpoint.
*/
export declare const Destination: {
readonly Internal: "internal";
readonly External: "external";
};
/**
* Tracing destination this rule applies to. Derived server-side when project tracing is computed; accepted here so a computed config can round-trip through this endpoint.
*/
export type Destination = ClosedEnum<typeof Destination>;
export type SamplingRules = {
/**
* Sampling rate from 0 to 1
*/
rate: number;
/**
* Environment to apply sampling to
*/
env?: UpdateProjectEnv | undefined;
/**
* Request path prefix to apply the sampling rule to
*/
requestPath?: string | undefined;
/**
* Tracing destination this rule applies to. Derived server-side when project tracing is computed; accepted here so a computed config can round-trip through this endpoint.
*/
destination?: Destination | undefined;
};
/**
* Tracing configuration for this project
*/
export type UpdateProjectTracing = {
/**
* Comma-separated list of drain endpoint domains
*/
domains?: string | undefined;
/**
* Paths to ignore for tracing
*/
ignorePaths?: Array<string> | undefined;
/**
* Sampling rules for trace collection
*/
samplingRules?: Array<SamplingRules> | undefined;
};
/**
* team: `https://oidc.vercel.com/[team_slug]` global: `https://oidc.vercel.com`
*/
export declare const UpdateProjectIssuerMode: {
readonly Team: "team";
readonly Global: "global";
};
/**
* team: `https://oidc.vercel.com/[team_slug]` global: `https://oidc.vercel.com`
*/
export type UpdateProjectIssuerMode = ClosedEnum<typeof UpdateProjectIssuerMode>;
/**
* OpenID Connect JSON Web Token generation configuration.
*/
export type UpdateProjectOidcTokenConfig = {
/**
* Whether or not to generate OpenID Connect JSON Web Tokens.
*
* @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
*/
enabled?: boolean | undefined;
/**
* team: `https://oidc.vercel.com/[team_slug]` global: `https://oidc.vercel.com`
*/
issuerMode?: UpdateProjectIssuerMode | undefined;
};
/**
* Specify if the password will apply to every Deployment Target or just Preview
*/
export declare const UpdateProjectDeploymentType: {
readonly All: "all";
readonly Preview: "preview";
readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
readonly AllExceptCustomDomains: "all_except_custom_domains";
};
/**
* Specify if the password will apply to every Deployment Target or just Preview
*/
export type UpdateProjectDeploymentType = ClosedEnum<typeof UpdateProjectDeploymentType>;
/**
* Allows to protect project deployments with a password
*/
export type UpdateProjectPasswordProtection = {
/**
* Specify if the password will apply to every Deployment Target or just Preview
*/
deploymentType: UpdateProjectDeploymentType;
/**
* The password that will be used to protect Project Deployments
*/
password?: string | null | undefined;
};
export declare const UpdateProjectProjectsDeploymentType: {
readonly All: "all";
readonly Preview: "preview";
readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
readonly AllExceptCustomDomains: "all_except_custom_domains";
};
export type UpdateProjectProjectsDeploymentType = ClosedEnum<typeof UpdateProjectProjectsDeploymentType>;
/**
* Passport configuration for the project.
*/
export type UpdateProjectPassport = {
connectorId: string;
deploymentType?: UpdateProjectProjectsDeploymentType | undefined;
};
/**
* The Vercel region sandboxes in this project are created in by default.
*/
export declare const UpdateProjectRegion: {
readonly Iad1: "iad1";
readonly Sfo1: "sfo1";
readonly Cle1: "cle1";
readonly Cdg1: "cdg1";
readonly Fra1: "fra1";
readonly Arn1: "arn1";
readonly Sin1: "sin1";
readonly Pdx1: "pdx1";
readonly Lhr1: "lhr1";
readonly Icn1: "icn1";
readonly Bom1: "bom1";
readonly Cpt1: "cpt1";
readonly Dub1: "dub1";
readonly Gru1: "gru1";
readonly Hkg1: "hkg1";
readonly Syd1: "syd1";
readonly Yul1: "yul1";
readonly Hnd1: "hnd1";
readonly Kix1: "kix1";
};
/**
* The Vercel region sandboxes in this project are created in by default.
*/
export type UpdateProjectRegion = ClosedEnum<typeof UpdateProjectRegion>;
export declare const UpdateProjectFailoverRegions: {
readonly Iad1: "iad1";
readonly Sfo1: "sfo1";
readonly Cle1: "cle1";
readonly Cdg1: "cdg1";
readonly Fra1: "fra1";
readonly Arn1: "arn1";
readonly Sin1: "sin1";
readonly Pdx1: "pdx1";
readonly Lhr1: "lhr1";
readonly Icn1: "icn1";
readonly Bom1: "bom1";
readonly Cpt1: "cpt1";
readonly Dub1: "dub1";
readonly Gru1: "gru1";
readonly Hkg1: "hkg1";
readonly Syd1: "syd1";
readonly Yul1: "yul1";
readonly Hnd1: "hnd1";
readonly Kix1: "kix1";
};
export type UpdateProjectFailoverRegions = ClosedEnum<typeof UpdateProjectFailoverRegions>;
/**
* Specifies the default region and failover regions for sandboxes created in the project
*/
export type UpdateProjectSandbox = {
/**
* The Vercel region sandboxes in this project are created in by default.
*/
region?: UpdateProjectRegion | undefined;
/**
* The regions sandboxes in this project fall back to when they cannot be created in `region`.
*/
failoverRegions?: Array<UpdateProjectFailoverRegions> | undefined;
};
/**
* Specify if the Vercel Authentication (SSO Protection) will apply to every Deployment Target or just Preview
*/
export declare const UpdateProjectProjectsRequestDeploymentType: {
readonly All: "all";
readonly Preview: "preview";
readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
readonly AllExceptCustomDomains: "all_except_custom_domains";
};
/**
* Specify if the Vercel Authentication (SSO Protection) will apply to every Deployment Target or just Preview
*/
export type UpdateProjectProjectsRequestDeploymentType = ClosedEnum<typeof UpdateProjectProjectsRequestDeploymentType>;
/**
* Ensures visitors to your Preview Deployments are logged into Vercel and have a minimum of Viewer access on your team
*/
export type UpdateProjectSsoProtection = {
/**
* Specify if the Vercel Authentication (SSO Protection) will apply to every Deployment Target or just Preview
*/
deploymentType?: UpdateProjectProjectsRequestDeploymentType | undefined;
};
/**
* Specify if the Trusted IPs will apply to every Deployment Target or just Preview
*/
export declare const UpdateProjectProjectsRequestRequestBodyDeploymentType: {
readonly All: "all";
readonly Preview: "preview";
readonly Production: "production";
readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
readonly AllExceptCustomDomains: "all_except_custom_domains";
};
/**
* Specify if the Trusted IPs will apply to every Deployment Target or just Preview
*/
export type UpdateProjectProjectsRequestRequestBodyDeploymentType = ClosedEnum<typeof UpdateProjectProjectsRequestRequestBodyDeploymentType>;
export type Addresses = {
/**
* The IP addresses that are allowlisted. Supports IPv4 addresses and CIDR notations. IPv6 is not supported
*/
value: string;
/**
* An optional note explaining what the IP address or subnet is used for
*/
note?: string | undefined;
};
/**
* exclusive: ip match is enough to bypass deployment protection (regardless of other settings). additional: ip must match + any other protection should be also provided (password, vercel auth, shareable link, automation bypass header, automation bypass query param)
*/
export declare const ProtectionMode: {
readonly Exclusive: "exclusive";
readonly Additional: "additional";
};
/**
* exclusive: ip match is enough to bypass deployment protection (regardless of other settings). additional: ip must match + any other protection should be also provided (password, vercel auth, shareable link, automation bypass header, automation bypass query param)
*/
export type ProtectionMode = ClosedEnum<typeof ProtectionMode>;
/**
* Restricts access to deployments based on the incoming request IP address
*/
export type UpdateProjectTrustedIps = {
/**
* Specify if the Trusted IPs will apply to every Deployment Target or just Preview
*/
deploymentType: UpdateProjectProjectsRequestRequestBodyDeploymentType;
addresses: Array<Addresses>;
/**
* exclusive: ip match is enough to bypass deployment protection (regardless of other settings). additional: ip must match + any other protection should be also provided (password, vercel auth, shareable link, automation bypass header, automation bypass query param)
*/
protectionMode: ProtectionMode;
};
export declare const ToPreset: {
readonly AllCustom: "all-custom";
};
export type ToPreset = ClosedEnum<typeof ToPreset>;
export type To2 = {
slugs?: Array<string> | undefined;
preset: ToPreset;
};
export declare const Preset: {
readonly AllCustom: "all-custom";
};
export type Preset = ClosedEnum<typeof Preset>;
export type To1 = {
slugs: Array<string>;
preset?: Preset | undefined;
};
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
export type To = To1 | To2;
export declare const UpdateProjectFromPreset: {
readonly AllCustom: "all-custom";
};
export type UpdateProjectFromPreset = ClosedEnum<typeof UpdateProjectFromPreset>;
export type From2 = {
slugs?: Array<string> | undefined;
preset: UpdateProjectFromPreset;
};
export declare const FromPreset: {
readonly AllCustom: "all-custom";
};
export type FromPreset = ClosedEnum<typeof FromPreset>;
export type From1 = {
slugs: Array<string>;
preset?: FromPreset | undefined;
};
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
export type From = From1 | From2;
export type CustomAllow = {
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
to: To1 | To2;
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
from: From1 | From2;
};
export type UpdateProjectProjects = {
/**
* The label or description of the trusted source
*/
label?: string | undefined;
/**
* Optional overrides for the default same-env-by-slug matching.
*/
customAllow?: Array<CustomAllow> | undefined;
};
export declare const UpdateProjectToProjectsPreset: {
readonly AllCustom: "all-custom";
};
export type UpdateProjectToProjectsPreset = ClosedEnum<typeof UpdateProjectToProjectsPreset>;
export type UpdateProjectTo2 = {
slugs?: Array<string> | undefined;
preset: UpdateProjectToProjectsPreset;
};
export declare const UpdateProjectToPreset: {
readonly AllCustom: "all-custom";
};
export type UpdateProjectToPreset = ClosedEnum<typeof UpdateProjectToPreset>;
export type UpdateProjectTo1 = {
slugs: Array<string>;
preset?: UpdateProjectToPreset | undefined;
};
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
export type UpdateProjectTo = UpdateProjectTo1 | UpdateProjectTo2;
export type OidcProviders = {
/**
* The label or description of the trusted source
*/
label?: string | undefined;
/**
* A set of environments, expressed as explicit slugs, a named preset, or both. At least one of `slugs` or `preset` must be set.
*/
to: UpdateProjectTo1 | UpdateProjectTo2;
claims: {
[k: string]: Array<string>;
};
};
/**
* Deployment Protection Trusted Sources
*/
export type TrustedSources = {
/**
* Allow same-team Vercel CI access to preview deployments built from the same repository as the CI run. The deployment source repository, not the current project repository link, is authoritative. Defaults to enabled when not stored. Omitting this field preserves its stored value, including when trustedSources is cleared. Set true explicitly to re-enable.
*/
enableVercelCiSameRepository?: boolean | undefined;
projects?: {
[k: string]: UpdateProjectProjects;
} | undefined;
oidcProviders?: {
[k: string]: Array<OidcProviders>;
} | undefined;
};
export type UpdateProjectEnvironmentsProjects2 = {
type: "custom";
environmentId: string;
};
export declare const UpdateProjectEnvironmentsProjectsTarget: {
readonly Production: "production";
readonly Preview: "preview";
};
export type UpdateProjectEnvironmentsProjectsTarget = ClosedEnum<typeof UpdateProjectEnvironmentsProjectsTarget>;
export type UpdateProjectEnvironments1 = {
type: "system";
target: UpdateProjectEnvironmentsProjectsTarget;
};
export type GitSourcesEnvironments = UpdateProjectEnvironments1 | UpdateProjectEnvironmentsProjects2;
export type UpdateProjectSources2 = {
provider: "gitlab";
namespace: string;
project?: string | undefined;
};
export declare const UpdateProjectSourcesProjectsProvider: {
readonly Github: "github";
readonly Bitbucket: "bitbucket";
};
export type UpdateProjectSourcesProjectsProvider = ClosedEnum<typeof UpdateProjectSourcesProjectsProvider>;
export type UpdateProjectSources1 = {
provider: UpdateProjectSourcesProjectsProvider;
org: string;
repo?: string | undefined;
};
export type GitSourcesSources = (UpdateProjectSources1 & {
provider: "github";
}) | (UpdateProjectSources1 & {
provider: "bitbucket";
}) | UpdateProjectSources2;
export type GitSources1 = {
enabled: boolean;
environments: Array<UpdateProjectEnvironments1 | UpdateProjectEnvironmentsProjects2>;
sources: Array<(UpdateProjectSources1 & {
provider: "github";
}) | (UpdateProjectSources1 & {
provider: "bitbucket";
}) | UpdateProjectSources2>;
};
export type DeploymentPolicyGitSources = Array<GitSources1> | string;
export type UpdateProjectEnvironments2 = {
type: "custom";
environmentId: string;
};
export declare const UpdateProjectEnvironmentsTarget: {
readonly Production: "production";
readonly Preview: "preview";
};
export type UpdateProjectEnvironmentsTarget = ClosedEnum<typeof UpdateProjectEnvironmentsTarget>;
export type UpdateProjectEnvironmentsProjects1 = {
type: "system";
target: UpdateProjectEnvironmentsTarget;
};
export type DeploymentSourcesEnvironments = UpdateProjectEnvironmentsProjects1 | UpdateProjectEnvironments2;
export declare const DeploymentSourcesSources: {
readonly Git: "git";
readonly Cli: "cli";
readonly RestApi: "rest-api";
readonly DeployHook: "deploy-hook";
readonly Integration: "integration";
readonly V0: "v0";
};
export type DeploymentSourcesSources = ClosedEnum<typeof DeploymentSourcesSources>;
export type DeploymentSources1 = {
enabled: boolean;
environments: Array<UpdateProjectEnvironmentsProjects1 | UpdateProjectEnvironments2>;
sources: Array<DeploymentSourcesSources>;
};
export type DeploymentPolicyDeploymentSources = Array<DeploymentSources1> | string;
/**
* Composable deployment-time policy. Each rule type holds a list of rules, one per environment scope.
*/
export type DeploymentPolicy1 = {
gitSources?: Array<GitSources1> | string | undefined;
deploymentSources?: Array<DeploymentSources1> | string | undefined;
};
export type UpdateProjectDeploymentPolicy = DeploymentPolicy1 | string;
export type UpdateProjectPaths = {
/**
* The regex path that should not be protected by Deployment Protection
*/
value: string;
};
/**
* Specify a list of paths that should not be protected by Deployment Protection to enable Cors preflight requests
*/
export type UpdateProjectOptionsAllowlist = {
paths: Array<UpdateProjectPaths>;
};
export type ConnectConfigurations1 = {
/**
* The ID of the environment
*/
envId: string;
/**
* The ID of the Secure Compute network
*/
connectConfigurationId: string;
/**
* Whether the configuration should be passive, meaning builds will not run there and only passive Serverless Functions will be deployed
*/
passive: boolean;
/**
* Flag saying if project builds should use Secure Compute
*/
buildsEnabled: boolean;
};
export type ConnectConfigurations = ConnectConfigurations1;
/**
* Whether the toast was dismissed, the action was accepted, or the dismissal with this key should be removed
*/
export declare const UpdateProjectAction: {
readonly Cancel: "cancel";
readonly Accept: "accept";
readonly Delete: "delete";
};
/**
* Whether the toast was dismissed, the action was accepted, or the dismissal with this key should be removed
*/
export type UpdateProjectAction = ClosedEnum<typeof UpdateProjectAction>;
export type PreviousValue = number | boolean | string;
export type CurrentValue = number | boolean | string;
export type Value5 = {
previousValue: number | boolean | string;
currentValue: number | boolean | string;
};
export type UpdateProjectDismissedToasts = {
/**
* unique identifier for the dismissed toast
*/
key: string;
/**
* unix timestamp representing the time the toast was dimissed
*/
dismissedAt: number;
/**
* Whether the toast was dismissed, the action was accepted, or the dismissal with this key should be removed
*/
action: UpdateProjectAction;
value?: any | undefined;
};
export type UpdateProjectRequestBody = {
autoExposeSystemEnvs?: boolean | undefined;
autoAssignCustomDomains?: boolean | undefined;
autoAssignCustomDomainsUpdatedBy?: string | undefined;
/**
* The build command for this project. When `null` is used this value will be automatically detected
*/
buildCommand?: string | null | undefined;
commandForIgnoringBuildStep?: string | null | undefined;
/**
* Specifies whether customer support can see git source for a deployment
*/
customerSupportCodeVisibility?: boolean | undefined;
/**
* The dev command for this project. When `null` is used this value will be automatically detected
*/
devCommand?: string | null | undefined;
directoryListing?: boolean | undefined;
/**
* The framework that is being used for this project. When `null` is used no framework is selected
*/
framework?: UpdateProjectFramework | null | undefined;
/**
* Specifies whether PRs from Git forks should require a team member's authorization before it can be deployed
*/
gitForkProtection?: boolean | undefined;
/**
* Specifies whether Git LFS is enabled for this project.
*/
gitLFS?: boolean | undefined;
/**
* Specifies whether sourcemaps are protected and require authentication to access.
*/
protectedSourcemaps?: boolean | undefined;
/**
* The install command for this project. When `null` is used this value will be automatically detected
*/
installCommand?: string | null | undefined;
/**
* The desired name for the project
*/
name?: string | undefined;
nodeVersion?: UpdateProjectNodeVersion | undefined;
/**
* The output directory of the project. When `null` is used this value will be automatically detected
*/
outputDirectory?: string | null | undefined;
/**
* Specifies whether preview deployments are disabled for this project.
*/
previewDeploymentsDisabled?: boolean | null | undefined;
/**
* Custom domain suffix for preview deployments. Takes precedence over team-level suffix. Must be a domain owned by the team.
*/
previewDeploymentSuffix?: string | null | undefined;
/**
* Specifies resource override configuration for the project
*/
resourceConfig?: UpdateProjectResourceConfig | undefined;
/**
* Deprecated. Accepted for backwards compatibility but ignored.
*
* @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
*/
publicSource?: boolean | null | undefined;
/**
* The name of a directory or relative path to the source code of your project. When `null` is used it will default to the project root
*/
rootDirectory?: string | null | undefined;
/**
* The region to deploy Serverless Functions in this project
*/
serverlessFunctionRegion?: string | null | undefined;
/**
* Specifies whether Zero Config Failover is enabled for this project.
*/
serverlessFunctionZeroConfigFailover?: boolean | undefined;
/**
* Deployments created before this absolute datetime have Skew Protection disabled. Value is in milliseconds since epoch to match \"createdAt\" fields.
*/
skewProtectionBoundaryAt?: number | undefined;
/**
* Deployments created before this rolling window have Skew Protection disabled. Value is in seconds to match \"revalidate\" fields.
*/
skewProtectionMaxAge?: number | undefined;
/**
* Cross-site domains allowed to fetch skew-protected assets (hostnames, optionally with leading wildcard like *.example.com).
*/
skewProtectionAllowedDomains?: Array<string> | undefined;
/**
* Opts-out of the message prompting a CLI user to connect a Git repository in `vercel link`.
*
* @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
*/
skipGitConnectDuringLink?: boolean | undefined;
/**
* Indicates if there are source files outside of the root directory
*/
sourceFilesOutsideRootDirectory?: boolean | undefined;
/**
* Opt-in to preview toolbar on the project level
*/
enablePreviewFeedback?: boolean | null | undefined;
/**
* Opt-in to production toolbar on the project level
*/
enableProductionFeedback?: boolean | null | undefined;
/**
* Opt-in to skip deployments when there are no changes to the root directory and its dependencies
*/
enableAffectedProjectsDeployments?: boolean | undefined;
/**
* Specifies whether external rewrite caching is enabled for this project.
*/
enableExternalRewriteCaching?: boolean | undefined;
/**
* Manage Static IPs for this project
*/
staticIps?: UpdateProjectStaticIps | undefined;
/**
* Tracing configuration for this project
*/
tracing?: UpdateProjectTracing | null | undefined;
/**
* OpenID Connect JSON Web Token generation configuration.
*/
oidcTokenConfig?: UpdateProjectOidcTokenConfig | undefined;
/**
* Allows to protect project deployments with a password
*/
passwordProtection?: UpdateProjectPasswordProtection | null | undefined;
/**
* Passport configuration for the project.
*/
passport?: UpdateProjectPassport | null | undefined;
/**
* Specifies the default region and failover regions for sandboxes created in the project
*/
sandbox?: UpdateProjectSandbox | undefined;
/**
* Ensures visitors to your Preview Deployments are logged into Vercel and have a minimum of Viewer access on your team
*/
ssoProtection?: UpdateProjectSsoProtection | null | undefined;
/**
* Restricts access to deployments based on the incoming request IP address
*/
trustedIps?: UpdateProjectTrustedIps | null | undefined;
/**
* Deployment Protection Trusted Sources
*/
trustedSources?: TrustedSources | null | undefined;
deploymentPolicy?: DeploymentPolicy1 | string | undefined;
/**
* Specify a list of paths that should not be protected by Deployment Protection to enable Cors preflight requests
*/
optionsAllowlist?: UpdateProjectOptionsAllowlist | null | undefined;
/**
* The list of connections from project environment to Secure Compute network
*/
connectConfigurations?: Array<ConnectConfigurations1> | null | undefined;
/**
* An array of objects representing a Dismissed Toast in regards to a Project. Objects are either merged with existing toasts (on key match), or added to the `dimissedToasts` array.`
*/
dismissedToasts?: Array<UpdateProjectDismissedToasts> | undefined;
};
export type UpdateProjectRequest = {
/**
* 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: UpdateProjectRequestBody;
};
export type UpdateProjectCreator4 = {
type: "system";
};
export type UpdateProjectCreatorIntegration = {
integrationId: string;
configurationId: string;
};
export type UpdateProjectCreator3 = {
type: "integration";
integration: UpdateProjectCreatorIntegration;
};
export type UpdateProjectCreatorApp = {
/**
* The internal ID of the Vercel App backing this principal.
*/
id: string;
/**
* The protocol-facing OAuth client ID. This may differ from {@link id} when Client ID Metadata Documents (CIMD) are used.
*/
clientId?: string | undefined;
};
export type UpdateProjectCreator2 = {
type: "app";
app: UpdateProjectCreatorApp;
};
export type UpdateProjectViaIntegration = {
integrationId: string;
configurationId: string;
};
/**
* Set when a Vercel App or Integration acts on behalf of a {@link User}. Captures user-consented OAuth delegation that the ACL layer may inspect to evaluate scope restrictions. This is NOT for impersonation or token-exchange provenance — those live on `auth.token`, not on the principal.
*/
export type UpdateProjectVia2 = {
type: "integration";
integration: UpdateProjectViaIntegration;
};
export type UpdateProjectViaApp = {
/**
* The internal ID of the Vercel App backing this principal.
*/
id: string;
/**
* The protocol-facing OAuth client ID. This may differ from {@link id} when Client ID Metadata Documents (CIMD) are used.
*/
clientId?: string | undefined;
};
/**
* Set when a Vercel App or Integration acts on behalf of a {@link User}. Captures user-consented OAuth delegation that the ACL layer may inspect to evaluate scope restrictions. This is NOT for impersonation or token-exchange provenance — those live on `auth.token`, not on the principal.
*/
export type UpdateProjectVia1 = {
type: "app";
app: UpdateProjectViaApp;
};
export type UpdateProjectCreatorVia = UpdateProjectVia1 | UpdateProjectVia2;
export type UpdateProjectCreatorUser = {
id: string;
};
export type UpdateProjectCreator1 = {
type: "user";
via: UpdateProjectVia1 | UpdateProjectVia2 | null;
user: UpdateProjectCreatorUser;
};
export type UpdateProjectCreator = UpdateProjectCreator1 | UpdateProjectCreator2 | UpdateProjectCreator3 | UpdateProjectCreator4;
export declare const UpdateProjectConfiguredBy: {
readonly A: "A";
readonly Cname: "CNAME";
readonly Dns01: "dns-01";
readonly Http: "http";
};
export type UpdateProjectConfiguredBy = ClosedEnum<typeof UpdateProjectConfiguredBy>;
export type UpdateProjectProjectsResponseAliasAssigned = number | boolean;
export type UpdateProjectProjectsResponseAliasError = {
code: string;
message: string;
};
/**
* The type of matching to perform
*/
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType: {
readonly EndsWith: "endsWith";
readonly Equals: "equals";
readonly StartsWith: "startsWith";
};
/**
* The type of matching to perform
*/
export type UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType = ClosedEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType>;
export type UpdateProjectProjectsResponse200BranchMatcher = {
/**
* The type of matching to perform
*/
type: UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType;
/**
* The pattern to match against branch names
*/
pattern: string;
};
export type UpdateProjectProjectsResponseBuilds = {
use: string;
src?: string | undefined;
dest?: string | undefined;
};
export declare const UpdateProjectProjectsResponseChecksConclusion: {
readonly Canceled: "canceled";
readonly Failed: "failed";
readonly Skipped: "skipped";
readonly Succeeded: "succeeded";
};
export type UpdateProjectProjectsResponseChecksConclusion = ClosedEnum<typeof UpdateProjectProjectsResponseChecksConclusion>;
export declare const UpdateProjectProjectsResponseChecksState: {
readonly Completed: "completed";
readonly Registered: "registered";
readonly Running: "running";
};
export type UpdateProjectProjectsResponseChecksState = ClosedEnum<typeof UpdateProjectProjectsResponseChecksState>;
export type UpdateProjectProjectsResponse200Creator = {
email: string;
githubLogin?: string | undefined;
gitlabLogin?: string | undefined;
uid: string;
username: string;
};
export type UpdateProjectProjectsResponseOidcTokenClaims = {
iss: string;
sub: string;
scope: string;
aud: string;
owner: string;
ownerId: string;
project: string;
projectId: string;
environment: string;
customEnvironmentId?: string | undefined;
mfeGroupIds?: Array<string> | undefined;
plan?: string | undefined;
};
export declare const UpdateProjectProjectsResponsePlan: {
readonly Enterprise: "enterprise";
readonly Hobby: "hobby";
readonly Pro: "pro";
};
export type UpdateProjectProjectsResponsePlan = ClosedEnum<typeof UpdateProjectProjectsResponsePlan>;
export declare const UpdateProjectProjectsResponseReadyState: {
readonly Blocked: "BLOCKED";
readonly Building: "BUILDING";
readonly Canceled: "CANCELED";
readonly Error: "ERROR";
readonly Initializing: "INITIALIZING";
readonly Queued: "QUEUED";
readonly Ready: "READY";
};
export type UpdateProjectProjectsResponseReadyState = ClosedEnum<typeof UpdateProjectProjectsResponseReadyState>;
export declare const UpdateProjectProjectsResponseReadySubstate: {
readonly Promoted: "PROMOTED";
readonly Rolling: "ROLLING";
readonly Staged: "STAGED";
};
export type UpdateProjectProjectsResponseReadySubstate = ClosedEnum<typeof UpdateProjectProjectsResponseReadySubstate>;
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType: {
readonly Lambdas: "LAMBDAS";
};
export type UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType = ClosedEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType>;
export type UpdateProjectDeployment = {
id: string;
alias?: Array<string> | undefined;
aliasAssigned?: number | boolean | null | undefined;
aliasError?: UpdateProjectProjectsResponseAliasError | null | undefined;
aliasFinal?: string | null | undefined;
automaticAliases?: Array<string> | undefined;
branchMatcher?: UpdateProjectProjectsResponse200BranchMatcher | undefined;
buildingAt?: number | undefined;
builds?: Array<UpdateProjectProjectsResponseBuilds> | undefined;
checksConclusion?: UpdateProjectProjectsResponseChecksConclusion | undefined;
checksState?: UpdateProjectProjectsResponseChecksState | undefined;
connectBuildsEnabled?: boolean | undefined;
connectConfigurationId?: string | undefined;
createdAt: number;
createdIn: string;
creator: UpdateProjectProjectsResponse200Creator | null;
deletedAt?: number | undefined;
deploymentHostname: string;
forced?: boolean | undefined;
name: string;
meta?: {
[k: string]: string;
} | undefined;
monorepoManager?: string | null | undefined;
oidcTokenClaims?: UpdateProjectProjectsResponseOidcTokenClaims | undefined;
plan: UpdateProjectProjectsResponsePlan;
/**
* Whether or not preview comments are enabled for the deployment
*/
previewCommentsEnabled?: boolean | undefined;
private: boolean;
readyAt?: number | undefined;
readyState: UpdateProjectProjectsResponseReadyState;
readySubstate?: UpdateProjectProjectsResponseReadySubstate | undefined;
requestedAt?: number | undefined;
target?: string | null | undefined;
teamId?: string | null | undefined;
type: UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType;
url: string;
/**
* Present for user creators; omitted for app/integration/system creators.
*/
userId?: string | undefined;
withCache?: boolean | undefined;
};
export declare const UpdateProjectEnvironment: {
readonly Preview: "preview";
readonly Production: "production";
};
export type UpdateProjectEnvironment = ClosedEnum<typeof UpdateProjectEnvironment>;
export declare const UpdateProjectTarget: {
readonly Preview: "PREVIEW";
readonly Production: "PRODUCTION";
readonly Staging: "STAGING";
};
export type UpdateProjectTarget = ClosedEnum<typeof UpdateProjectTarget>;
export type UpdateProjectAlias = {
configuredBy?: UpdateProjectConfiguredBy | null | undefined;
configuredChangedAt?: number | null | undefined;
createdAt?: number | null | undefined;
deployment: UpdateProjectDeployment | null;
domain: string;
environment: UpdateProjectEnvironment;
gitBranch?: string | null | undefined;
redirect?: string | null | undefined;
redirectStatusCode?: number | null | undefined;
target: UpdateProjectTarget;
};
export type UpdateProjectAnalytics = {
id: string;
canceledAt?: number | null | undefined;
disabledAt: number;
enabledAt: number;
paidAt?: number | undefined;
sampleRatePercent?: number | null | undefined;
spendLimitInDollars?: number | null | undefined;
};
export type UpdateProjectSpeedInsights = {
id: string;
enabledAt?: number | undefined;
disabledAt?: number | undefined;
canceledAt?: number | undefined;
hasData?: boolean | undefined;
/**
* When the first free (not Speed Insights Plus) production data point was observed, in ms. Set once by subscriber-analytics-events; projects that already had data before this field shipped get it backfilled on their next batch, so it reads "first free data point observed", not necessarily "first ever".
*/
dataReceivedAt?: number | undefined;
paidAt?: number | undefined;
};
export declare const UpdateProjectEnvId2: {
readonly Preview: "preview";
readonly Production: "production";
};
export type UpdateProjectEnvId2 = ClosedEnum<typeof UpdateProjectEnvId2>;
export type UpdateProjectEnvId = string | UpdateProjectEnvId2;
export type UpdateProjectAws = {
subnetIds: Array<string>;
securityGroupId?: string | undefined;
};
export type UpdateProjectConnectConfigurations = {
envId: string | UpdateProjectEnvId2;
connectConfigurationId: string;
dc?: string | undefined;
passive: boolean;
buildsEnabled: boolean;
aws?: UpdateProjectAws | 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 declare const UpdateProjectSource: {
readonly Api: "api";
};
/**
* The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
*/
export type UpdateProjectSource = ClosedEnum<typeof UpdateProjectSource>;
export type UpdateProjectDefinitions = {
/**
* 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?: UpdateProjectSource | 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 UpdateProjectCrons = {
/**
* 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<UpdateProjectDefinitions>;
};
export type UpdateProjectDataCache = {
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 UpdateProjectDeploymentExpiration = {
/**
* 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 UpdateProjectExpiration2 = {
/**
* 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 UpdateProjectExpiration1 = {
/**
* Unix ms timestamp when the project is scheduled to expire.
*/
expiresAt: number;
};
export type UpdateProjectExpiration = UpdateProjectExpiration2 | UpdateProjectExpiration1;
export declare const UpdateProjectTarget2: {
readonly Production: "production";
readonly Preview: "preview";
readonly Development: "development";
};
export type UpdateProjectTarget2 = ClosedEnum<typeof UpdateProjectTarget2>;
export type UpdateProjectProjectsTarget = Array<string> | UpdateProjectTarget2;
export declare const UpdateProjectType: {
readonly Encrypted: "encrypted";
readonly Plain: "plain";
readonly Secret: "secret";
readonly Sensitive: "sensitive";
readonly System: "system";
};
export type UpdateProjectType = ClosedEnum<typeof UpdateProjectType>;
/**
* User-facing config/secret model. When set, authoritative for new code paths. Legacy rows omit this field and callers fall back to existing `type` behavior.
*/
export declare const UpdateProjectVisibility: {
readonly Config: "config";
readonly Secret: "secret";
};
/**
* User-facing config/secret model. When set, authoritative for new code paths. Legacy rows omit this field and callers fall back to existing `type` behavior.
*/
export type UpdateProjectVisibility = ClosedEnum<typeof UpdateProjectVisibility>;
export type UpdateProjectContentHint17 = {
type: "flags-connection-string";
projectId: string;
};
export type UpdateProjectContentHint16 = {
type: "integration-store-secret";
storeId: string;
integrationId: string;
integrationProductId: string;
integrationConfigurationId: string;
};
export type UpdateProjectContentHint15 = {
type: "postgres-url-no-ssl";
storeId: string;
};
export type UpdateProjectContentHint14 = {
type: "postgres-database";
storeId: string;
};
export type UpdateProjectContentHint13 = {
type: "postgres-password";
storeId: string;
};
export type UpdateProjectContentHint12 = {
type: "postgres-host";
storeId: string;
};
export type UpdateProjectContentHint11 = {
type: "postgres-user";
storeId: string;
};
export type UpdateProjectContentHint10 = {
type: "postgres-prisma-url";
storeId: string;
};
export type UpdateProjectContentHint9 = {
type: "postgres-url-non-pooling";
storeId: string;
};
export type UpdateProjectContentHint8 = {
type: "postgres-url";
storeId: string;
};
export type UpdateProjectContentHint7 = {
type: "blob-webhook-public-key";
storeId: string;
};
export type UpdateProjectContentHint6 = {
type: "blob-store-id";
storeId: string;
};
export type UpdateProjectContentHint5 = {
type: "blob-read-write-token";
storeId: string;
};
export type UpdateProjectContentHint4 = {
type: "redis-rest-api-read-only-token";
storeId: string;
};
export type UpdateProjectContentHint3 = {
type: "redis-rest-api-token";
storeId: string;
};
export type UpdateProjectContentHint2 = {
type: "redis-rest-api-url";
storeId: string;
};
export type UpdateProjectContentHint1 = {
type: "redis-url";
storeId: string;
};
export type UpdateProjectContentHint = UpdateProjectContentHint1 | UpdateProjectContentHint2 | UpdateProjectContentHint3 | UpdateProjectContentHint4 | UpdateProjectContentHint5 | UpdateProjectContentHint6 | UpdateProjectContentHint7 | UpdateProjectContentHint8 | UpdateProjectContentHint9 | UpdateProjectContentHint10 | UpdateProjectContentHint11 | UpdateProjectContentHint12 | UpdateProjectContentHint13 | UpdateProjectContentHint14 | UpdateProjectContentHint15 | UpdateProjectContentHint16 | UpdateProjectContentHint17;
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType: {
readonly FlagsSecret: "flags-secret";
};
export type UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType = ClosedEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType>;
/**
* Similar to `contentHints`, but should not be exposed to the user.
*/
export type UpdateProjectInternalContentHint = {
type: UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType;
/**
* Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
*/
encryptedValue: string;
};
export type UpdateProjectProjectsEnv = {
target?: Array<string> | UpdateProjectTarget2 | undefined;
type: UpdateProjectType;
/**
* 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;
/**
* User-facing config/secret model. When set, authoritative for new code paths. Legacy rows omit this field and callers fall back to existing `type` behavior.
*/
visibility?: UpdateProjectVisibility | undefined;
edgeConfigId?: string | null | undefined;
edgeConfigTokenId?: string | null | undefined;
contentHint?: UpdateProjectContentHint1 | UpdateProjectContentHint2 | UpdateProjectContentHint3 | UpdateProjectContentHint4 | UpdateProjectContentHint5 | UpdateProjectContentHint6 | UpdateProjectContentHint7 | UpdateProjectContentHint8 | UpdateProjectContentHint9 | UpdateProjectContentHint10 | UpdateProjectContentHint11 | UpdateProjectContentHint12 | UpdateProjectContentHint13 | UpdateProjectContentHint14 | UpdateProjectContentHint15 | UpdateProjectContentHint16 | UpdateProjectContentHint17 | null | undefined;
/**
* Similar to `contentHints`, but should not be exposed to the user.
*/
internalContentHint?: UpdateProjectInternalContentHint | null | undefined;
comment?: string | undefined;
customEnvironmentIds?: Array<string> | undefined;
};
/**
* The type of environment (production, preview, or development)
*/
export declare const UpdateProjectProjectsType: {
readonly Development: "development";
readonly Preview: "preview";
readonly Production: "production";
};
/**
* The type of environment (production, preview, or development)
*/
export type UpdateProjectProjectsType = ClosedEnum<typeof UpdateProjectProjectsType>;
/**
* The type of matching to perform
*/
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType: {
readonly EndsWith: "endsWith";
readonly Equals: "equals";
readonly StartsWith: "startsWith";
};
/**
* The type of matching to perform
*/
export type UpdateProjectProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType = ClosedEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType>;
/** @internal */
export declare const UpdateProjectFramework$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectFramework>;
/** @internal */
export declare const UpdateProjectNodeVersion$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectNodeVersion>;
/** @internal */
export declare const UpdateProjectBuildMachineType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectBuildMachineType>;
/** @internal */
export declare const UpdateProjectBuildMachineSelection$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectBuildMachineSelection>;
/** @internal */
export declare const UpdateProjectConfiguration$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectConfiguration>;
/** @internal */
export type UpdateProjectBuildQueue$Outbound = {
configuration?: string | undefined;
};
/** @internal */
export declare const UpdateProjectBuildQueue$outboundSchema: z.ZodType<UpdateProjectBuildQueue$Outbound, z.ZodTypeDef, UpdateProjectBuildQueue>;
export declare function updateProjectBuildQueueToJSON(updateProjectBuildQueue: UpdateProjectBuildQueue): string;
/** @internal */
export declare const UpdateProjectFunctionDefaultMemoryType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectFunctionDefaultMemoryType>;
/** @internal */
export declare const UpdateProjectBuildMachineElasticReason$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectBuildMachineElasticReason>;
/** @internal */
export type UpdateProjectResourceConfig$Outbound = {
buildMachineType?: string | undefined;
buildMachineSelection?: string | undefined;
buildQueue?: UpdateProjectBuildQueue$Outbound | undefined;
fluid?: boolean | undefined;
functionDefaultRegions?: Array<string> | undefined;
functionDefaultTimeout?: number | undefined;
functionDefaultMemoryType?: string | undefined;
functionZeroConfigFailover?: boolean | undefined;
elasticConcurrencyEnabled?: boolean | undefined;
buildMachineElasticLastUpdated?: number | undefined;
buildMachineElasticReason?: string | undefined;
isNSNBDisabled?: boolean | undefined;
enableFunctionsBeta?: boolean | undefined;
};
/** @internal */
export declare const UpdateProjectResourceConfig$outboundSchema: z.ZodType<UpdateProjectResourceConfig$Outbound, z.ZodTypeDef, UpdateProjectResourceConfig>;
export declare function updateProjectResourceConfigToJSON(updateProjectResourceConfig: UpdateProjectResourceConfig): string;
/** @internal */
export type UpdateProjectStaticIps$Outbound = {
enabled: boolean;
};
/** @internal */
export declare const UpdateProjectStaticIps$outboundSchema: z.ZodType<UpdateProjectStaticIps$Outbound, z.ZodTypeDef, UpdateProjectStaticIps>;
export declare function updateProjectStaticIpsToJSON(updateProjectStaticIps: UpdateProjectStaticIps): string;
/** @internal */
export declare const UpdateProjectEnv$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectEnv>;
/** @internal */
export declare const Destination$outboundSchema: z.ZodNativeEnum<typeof Destination>;
/** @internal */
export type SamplingRules$Outbound = {
rate: number;
env?: string | undefined;
requestPath?: string | undefined;
destination?: string | undefined;
};
/** @internal */
export declare const SamplingRules$outboundSchema: z.ZodType<SamplingRules$Outbound, z.ZodTypeDef, SamplingRules>;
export declare function samplingRulesToJSON(samplingRules: SamplingRules): string;
/** @internal */
export type UpdateProjectTracing$Outbound = {
domains?: string | undefined;
ignorePaths?: Array<string> | undefined;
samplingRules?: Array<SamplingRules$Outbound> | undefined;
};
/** @internal */
export declare const UpdateProjectTracing$outboundSchema: z.ZodType<UpdateProjectTracing$Outbound, z.ZodTypeDef, UpdateProjectTracing>;
export declare function updateProjectTracingToJSON(updateProjectTracing: UpdateProjectTracing): string;
/** @internal */
export declare const UpdateProjectIssuerMode$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectIssuerMode>;
/** @internal */
export type UpdateProjectOidcTokenConfig$Outbound = {
enabled: boolean;
issuerMode: string;
};
/** @internal */
export declare const UpdateProjectOidcTokenConfig$outboundSchema: z.ZodType<UpdateProjectOidcTokenConfig$Outbound, z.ZodTypeDef, UpdateProjectOidcTokenConfig>;
export declare function updateProjectOidcTokenConfigToJSON(updateProjectOidcTokenConfig: UpdateProjectOidcTokenConfig): string;
/** @internal */
export declare const UpdateProjectDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDeploymentType>;
/** @internal */
export type UpdateProjectPasswordProtection$Outbound = {
deploymentType: string;
password?: string | null | undefined;
};
/** @internal */
export declare const UpdateProjectPasswordProtection$outboundSchema: z.ZodType<UpdateProjectPasswordProtection$Outbound, z.ZodTypeDef, UpdateProjectPasswordProtection>;
export declare function updateProjectPasswordProtectionToJSON(updateProjectPasswordProtection: UpdateProjectPasswordProtection): string;
/** @internal */
export declare const UpdateProjectProjectsDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsDeploymentType>;
/** @internal */
export type UpdateProjectPassport$Outbound = {
connectorId: string;
deploymentType: string;
};
/** @internal */
export declare const UpdateProjectPassport$outboundSchema: z.ZodType<UpdateProjectPassport$Outbound, z.ZodTypeDef, UpdateProjectPassport>;
export declare function updateProjectPassportToJSON(updateProjectPassport: UpdateProjectPassport): string;
/** @internal */
export declare const UpdateProjectRegion$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectRegion>;
/** @internal */
export declare const UpdateProjectFailoverRegions$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectFailoverRegions>;
/** @internal */
export type UpdateProjectSandbox$Outbound = {
region?: string | undefined;
failoverRegions?: Array<string> | undefined;
};
/** @internal */
export declare const UpdateProjectSandbox$outboundSchema: z.ZodType<UpdateProjectSandbox$Outbound, z.ZodTypeDef, UpdateProjectSandbox>;
export declare function updateProjectSandboxToJSON(updateProjectSandbox: UpdateProjectSandbox): string;
/** @internal */
export declare const UpdateProjectProjectsRequestDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsRequestDeploymentType>;
/** @internal */
export type UpdateProjectSsoProtection$Outbound = {
deploymentType: string;
};
/** @internal */
export declare const UpdateProjectSsoProtection$outboundSchema: z.ZodType<UpdateProjectSsoProtection$Outbound, z.ZodTypeDef, UpdateProjectSsoProtection>;
export declare function updateProjectSsoProtectionToJSON(updateProjectSsoProtection: UpdateProjectSsoProtection): string;
/** @internal */
export declare const UpdateProjectProjectsRequestRequestBodyDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsRequestRequestBodyDeploymentType>;
/** @internal */
export type Addresses$Outbound = {
value: string;
note?: string | undefined;
};
/** @internal */
export declare const Addresses$outboundSchema: z.ZodType<Addresses$Outbound, z.ZodTypeDef, Addresses>;
export declare function addressesToJSON(addresses: Addresses): string;
/** @internal */
export declare const ProtectionMode$outboundSchema: z.ZodNativeEnum<typeof ProtectionMode>;
/** @internal */
export type UpdateProjectTrustedIps$Outbound = {
deploymentType: string;
addresses: Array<Addresses$Outbound>;
protectionMode: string;
};
/** @internal */
export declare const UpdateProjectTrustedIps$outboundSchema: z.ZodType<UpdateProjectTrustedIps$Outbound, z.ZodTypeDef, UpdateProjectTrustedIps>;
export declare function updateProjectTrustedIpsToJSON(updateProjectTrustedIps: UpdateProjectTrustedIps): string;
/** @internal */
export declare const ToPreset$outboundSchema: z.ZodNativeEnum<typeof ToPreset>;
/** @internal */
export type To2$Outbound = {
slugs?: Array<string> | undefined;
preset: string;
};
/** @internal */
export declare const To2$outboundSchema: z.ZodType<To2$Outbound, z.ZodTypeDef, To2>;
export declare function to2ToJSON(to2: To2): string;
/** @internal */
export declare const Preset$outboundSchema: z.ZodNativeEnum<typeof Preset>;
/** @internal */
export type To1$Outbound = {
slugs: Array<string>;
preset?: string | undefined;
};
/** @internal */
export declare const To1$outboundSchema: z.ZodType<To1$Outbound, z.ZodTypeDef, To1>;
export declare function to1ToJSON(to1: To1): string;
/** @internal */
export type To$Outbound = To1$Outbound | To2$Outbound;
/** @internal */
export declare const To$outboundSchema: z.ZodType<To$Outbound, z.ZodTypeDef, To>;
export declare function toToJSON(to: To): string;
/** @internal */
export declare const UpdateProjectFromPreset$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectFromPreset>;
/** @internal */
export type From2$Outbound = {
slugs?: Array<string> | undefined;
preset: string;
};
/** @internal */
export declare const From2$outboundSchema: z.ZodType<From2$Outbound, z.ZodTypeDef, From2>;
export declare function from2ToJSON(from2: From2): string;
/** @internal */
export declare const FromPreset$outboundSchema: z.ZodNativeEnum<typeof FromPreset>;
/** @internal */
export type From1$Outbound = {
slugs: Array<string>;
preset?: string | undefined;
};
/** @internal */
export declare const From1$outboundSchema: z.ZodType<From1$Outbound, z.ZodTypeDef, From1>;
export declare function from1ToJSON(from1: From1): string;
/** @internal */
export type From$Outbound = From1$Outbound | From2$Outbound;
/** @internal */
export declare const From$outboundSchema: z.ZodType<From$Outbound, z.ZodTypeDef, From>;
export declare function fromToJSON(from: From): string;
/** @internal */
export type CustomAllow$Outbound = {
to: To1$Outbound | To2$Outbound;
from: From1$Outbound | From2$Outbound;
};
/** @internal */
export declare const CustomAllow$outboundSchema: z.ZodType<CustomAllow$Outbound, z.ZodTypeDef, CustomAllow>;
export declare function customAllowToJSON(customAllow: CustomAllow): string;
/** @internal */
export type UpdateProjectProjects$Outbound = {
label?: string | undefined;
customAllow?: Array<CustomAllow$Outbound> | undefined;
};
/** @internal */
export declare const UpdateProjectProjects$outboundSchema: z.ZodType<UpdateProjectProjects$Outbound, z.ZodTypeDef, UpdateProjectProjects>;
export declare function updateProjectProjectsToJSON(updateProjectProjects: UpdateProjectProjects): string;
/** @internal */
export declare const UpdateProjectToProjectsPreset$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectToProjectsPreset>;
/** @internal */
export type UpdateProjectTo2$Outbound = {
slugs?: Array<string> | undefined;
preset: string;
};
/** @internal */
export declare const UpdateProjectTo2$outboundSchema: z.ZodType<UpdateProjectTo2$Outbound, z.ZodTypeDef, UpdateProjectTo2>;
export declare function updateProjectTo2ToJSON(updateProjectTo2: UpdateProjectTo2): string;
/** @internal */
export declare const UpdateProjectToPreset$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectToPreset>;
/** @internal */
export type UpdateProjectTo1$Outbound = {
slugs: Array<string>;
preset?: string | undefined;
};
/** @internal */
export declare const UpdateProjectTo1$outboundSchema: z.ZodType<UpdateProjectTo1$Outbound, z.ZodTypeDef, UpdateProjectTo1>;
export declare function updateProjectTo1ToJSON(updateProjectTo1: UpdateProjectTo1): string;
/** @internal */
export type UpdateProjectTo$Outbound = UpdateProjectTo1$Outbound | UpdateProjectTo2$Outbound;
/** @internal */
export declare const UpdateProjectTo$outboundSchema: z.ZodType<UpdateProjectTo$Outbound, z.ZodTypeDef, UpdateProjectTo>;
export declare function updateProjectToToJSON(updateProjectTo: UpdateProjectTo): string;
/** @internal */
export type OidcProviders$Outbound = {
label?: string | undefined;
to: UpdateProjectTo1$Outbound | UpdateProjectTo2$Outbound;
claims: {
[k: string]: Array<string>;
};
};
/** @internal */
export declare const OidcProviders$outboundSchema: z.ZodType<OidcProviders$Outbound, z.ZodTypeDef, OidcProviders>;
export declare function oidcProvidersToJSON(oidcProviders: OidcProviders): string;
/** @internal */
export type TrustedSources$Outbound = {
enableVercelCiSameRepository?: boolean | undefined;
projects?: {
[k: string]: UpdateProjectProjects$Outbound;
} | undefined;
oidcProviders?: {
[k: string]: Array<OidcProviders$Outbound>;
} | undefined;
};
/** @internal */
export declare const TrustedSources$outboundSchema: z.ZodType<TrustedSources$Outbound, z.ZodTypeDef, TrustedSources>;
export declare function trustedSourcesToJSON(trustedSources: TrustedSources): string;
/** @internal */
export type UpdateProjectEnvironmentsProjects2$Outbound = {
type: "custom";
environmentId: string;
};
/** @internal */
export declare const UpdateProjectEnvironmentsProjects2$outboundSchema: z.ZodType<UpdateProjectEnvironmentsProjects2$Outbound, z.ZodTypeDef, UpdateProjectEnvironmentsProjects2>;
export declare function updateProjectEnvironmentsProjects2ToJSON(updateProjectEnvironmentsProjects2: UpdateProjectEnvironmentsProjects2): string;
/** @internal */
export declare const UpdateProjectEnvironmentsProjectsTarget$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectEnvironmentsProjectsTarget>;
/** @internal */
export type UpdateProjectEnvironments1$Outbound = {
type: "system";
target: string;
};
/** @internal */
export declare const UpdateProjectEnvironments1$outboundSchema: z.ZodType<UpdateProjectEnvironments1$Outbound, z.ZodTypeDef, UpdateProjectEnvironments1>;
export declare function updateProjectEnvironments1ToJSON(updateProjectEnvironments1: UpdateProjectEnvironments1): string;
/** @internal */
export type GitSourcesEnvironments$Outbound = UpdateProjectEnvironments1$Outbound | UpdateProjectEnvironmentsProjects2$Outbound;
/** @internal */
export declare const GitSourcesEnvironments$outboundSchema: z.ZodType<GitSourcesEnvironments$Outbound, z.ZodTypeDef, GitSourcesEnvironments>;
export declare function gitSourcesEnvironmentsToJSON(gitSourcesEnvironments: GitSourcesEnvironments): string;
/** @internal */
export type UpdateProjectSources2$Outbound = {
provider: "gitlab";
namespace: string;
project?: string | undefined;
};
/** @internal */
export declare const UpdateProjectSources2$outboundSchema: z.ZodType<UpdateProjectSources2$Outbound, z.ZodTypeDef, UpdateProjectSources2>;
export declare function updateProjectSources2ToJSON(updateProjectSources2: UpdateProjectSources2): string;
/** @internal */
export declare const UpdateProjectSourcesProjectsProvider$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectSourcesProjectsProvider>;
/** @internal */
export type UpdateProjectSources1$Outbound = {
provider: string;
org: string;
repo?: string | undefined;
};
/** @internal */
export declare const UpdateProjectSources1$outboundSchema: z.ZodType<UpdateProjectSources1$Outbound, z.ZodTypeDef, UpdateProjectSources1>;
export declare function updateProjectSources1ToJSON(updateProjectSources1: UpdateProjectSources1): string;
/** @internal */
export type GitSourcesSources$Outbound = (UpdateProjectSources1$Outbound & {
provider: "github";
}) | (UpdateProjectSources1$Outbound & {
provider: "bitbucket";
}) | UpdateProjectSources2$Outbound;
/** @internal */
export declare const GitSourcesSources$outboundSchema: z.ZodType<GitSourcesSources$Outbound, z.ZodTypeDef, GitSourcesSources>;
export declare function gitSourcesSourcesToJSON(gitSourcesSources: GitSourcesSources): string;
/** @internal */
export type GitSources1$Outbound = {
enabled: boolean;
environments: Array<UpdateProjectEnvironments1$Outbound | UpdateProjectEnvironmentsProjects2$Outbound>;
sources: Array<(UpdateProjectSources1$Outbound & {
provider: "github";
}) | (UpdateProjectSources1$Outbound & {
provider: "bitbucket";
}) | UpdateProjectSources2$Outbound>;
};
/** @internal */
export declare const GitSources1$outboundSchema: z.ZodType<GitSources1$Outbound, z.ZodTypeDef, GitSources1>;
export declare function gitSources1ToJSON(gitSources1: GitSources1): string;
/** @internal */
export type DeploymentPolicyGitSources$Outbound = Array<GitSources1$Outbound> | string;
/** @internal */
export declare const DeploymentPolicyGitSources$outboundSchema: z.ZodType<DeploymentPolicyGitSources$Outbound, z.ZodTypeDef, DeploymentPolicyGitSources>;
export declare function deploymentPolicyGitSourcesToJSON(deploymentPolicyGitSources: DeploymentPolicyGitSources): string;
/** @internal */
export type UpdateProjectEnvironments2$Outbound = {
type: "custom";
environmentId: string;
};
/** @internal */
export declare const UpdateProjectEnvironments2$outboundSchema: z.ZodType<UpdateProjectEnvironments2$Outbound, z.ZodTypeDef, UpdateProjectEnvironments2>;
export declare function updateProjectEnvironments2ToJSON(updateProjectEnvironments2: UpdateProjectEnvironments2): string;
/** @internal */
export declare const UpdateProjectEnvironmentsTarget$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectEnvironmentsTarget>;
/** @internal */
export type UpdateProjectEnvironmentsProjects1$Outbound = {
type: "system";
target: string;
};
/** @internal */
export declare const UpdateProjectEnvironmentsProjects1$outboundSchema: z.ZodType<UpdateProjectEnvironmentsProjects1$Outbound, z.ZodTypeDef, UpdateProjectEnvironmentsProjects1>;
export declare function updateProjectEnvironmentsProjects1ToJSON(updateProjectEnvironmentsProjects1: UpdateProjectEnvironmentsProjects1): string;
/** @internal */
export type DeploymentSourcesEnvironments$Outbound = UpdateProjectEnvironmentsProjects1$Outbound | UpdateProjectEnvironments2$Outbound;
/** @internal */
export declare const DeploymentSourcesEnvironments$outboundSchema: z.ZodType<DeploymentSourcesEnvironments$Outbound, z.ZodTypeDef, DeploymentSourcesEnvironments>;
export declare function deploymentSourcesEnvironmentsToJSON(deploymentSourcesEnvironments: DeploymentSourcesEnvironments): string;
/** @internal */
export declare const DeploymentSourcesSources$outboundSchema: z.ZodNativeEnum<typeof DeploymentSourcesSources>;
/** @internal */
export type DeploymentSources1$Outbound = {
enabled: boolean;
environments: Array<UpdateProjectEnvironmentsProjects1$Outbound | UpdateProjectEnvironments2$Outbound>;
sources: Array<string>;
};
/** @internal */
export declare const DeploymentSources1$outboundSchema: z.ZodType<DeploymentSources1$Outbound, z.ZodTypeDef, DeploymentSources1>;
export declare function deploymentSources1ToJSON(deploymentSources1: DeploymentSources1): string;
/** @internal */
export type DeploymentPolicyDeploymentSources$Outbound = Array<DeploymentSources1$Outbound> | string;
/** @internal */
export declare const DeploymentPolicyDeploymentSources$outboundSchema: z.ZodType<DeploymentPolicyDeploymentSources$Outbound, z.ZodTypeDef, DeploymentPolicyDeploymentSources>;
export declare function deploymentPolicyDeploymentSourcesToJSON(deploymentPolicyDeploymentSources: DeploymentPolicyDeploymentSources): string;
/** @internal */
export type DeploymentPolicy1$Outbound = {
gitSources?: Array<GitSources1$Outbound> | string | undefined;
deploymentSources?: Array<DeploymentSources1$Outbound> | string | undefined;
};
/** @internal */
export declare const DeploymentPolicy1$outboundSchema: z.ZodType<DeploymentPolicy1$Outbound, z.ZodTypeDef, DeploymentPolicy1>;
export declare function deploymentPolicy1ToJSON(deploymentPolicy1: DeploymentPolicy1): string;
/** @internal */
export type UpdateProjectDeploymentPolicy$Outbound = DeploymentPolicy1$Outbound | string;
/** @internal */
export declare const UpdateProjectDeploymentPolicy$outboundSchema: z.ZodType<UpdateProjectDeploymentPolicy$Outbound, z.ZodTypeDef, UpdateProjectDeploymentPolicy>;
export declare function updateProjectDeploymentPolicyToJSON(updateProjectDeploymentPolicy: UpdateProjectDeploymentPolicy): string;
/** @internal */
export type UpdateProjectPaths$Outbound = {
value: string;
};
/** @internal */
export declare const UpdateProjectPaths$outboundSchema: z.ZodType<UpdateProjectPaths$Outbound, z.ZodTypeDef, UpdateProjectPaths>;
export declare function updateProjectPathsToJSON(updateProjectPaths: UpdateProjectPaths): string;
/** @internal */
export type UpdateProjectOptionsAllowlist$Outbound = {
paths: Array<UpdateProjectPaths$Outbound>;
};
/** @internal */
export declare const UpdateProjectOptionsAllowlist$outboundSchema: z.ZodType<UpdateProjectOptionsAllowlist$Outbound, z.ZodTypeDef, UpdateProjectOptionsAllowlist>;
export declare function updateProjectOptionsAllowlistToJSON(updateProjectOptionsAllowlist: UpdateProjectOptionsAllowlist): string;
/** @internal */
export type ConnectConfigurations1$Outbound = {
envId: string;
connectConfigurationId: string;
passive: boolean;
buildsEnabled: boolean;
};
/** @internal */
export declare const ConnectConfigurations1$outboundSchema: z.ZodType<ConnectConfigurations1$Outbound, z.ZodTypeDef, ConnectConfigurations1>;
export declare function connectConfigurations1ToJSON(connectConfigurations1: ConnectConfigurations1): string;
/** @internal */
export type ConnectConfigurations$Outbound = ConnectConfigurations1$Outbound;
/** @internal */
export declare const ConnectConfigurations$outboundSchema: z.ZodType<ConnectConfigurations$Outbound, z.ZodTypeDef, ConnectConfigurations>;
export declare function connectConfigurationsToJSON(connectConfigurations: ConnectConfigurations): string;
/** @internal */
export declare const UpdateProjectAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectAction>;
/** @internal */
export type PreviousValue$Outbound = number | boolean | string;
/** @internal */
export declare const PreviousValue$outboundSchema: z.ZodType<PreviousValue$Outbound, z.ZodTypeDef, PreviousValue>;
export declare function previousValueToJSON(previousValue: PreviousValue): string;
/** @internal */
export type CurrentValue$Outbound = number | boolean | string;
/** @internal */
export declare const CurrentValue$outboundSchema: z.ZodType<CurrentValue$Outbound, z.ZodTypeDef, CurrentValue>;
export declare function currentValueToJSON(currentValue: CurrentValue): string;
/** @internal */
export type Value5$Outbound = {
previousValue: number | boolean | string;
currentValue: number | boolean | string;
};
/** @internal */
export declare const Value5$outboundSchema: z.ZodType<Value5$Outbound, z.ZodTypeDef, Value5>;
export declare function value5ToJSON(value5: Value5): string;
/** @internal */
export type UpdateProjectDismissedToasts$Outbound = {
key: string;
dismissedAt: number;
action: string;
value?: any | undefined;
};
/** @internal */
export declare const UpdateProjectDismissedToasts$outboundSchema: z.ZodType<UpdateProjectDismissedToasts$Outbound, z.ZodTypeDef, UpdateProjectDismissedToasts>;
export declare function updateProjectDismissedToastsToJSON(updateProjectDismissedToasts: UpdateProjectDismissedToasts): string;
/** @internal */
export type UpdateProjectRequestBody$Outbound = {
autoExposeSystemEnvs?: boolean | undefined;
autoAssignCustomDomains?: boolean | undefined;
autoAssignCustomDomainsUpdatedBy?: string | undefined;
buildCommand?: string | null | undefined;
commandForIgnoringBuildStep?: string | null | undefined;
customerSupportCodeVisibility?: boolean | undefined;
devCommand?: string | null | undefined;
directoryListing?: boolean | undefined;
framework?: string | null | undefined;
gitForkProtection?: boolean | undefined;
gitLFS?: boolean | undefined;
protectedSourcemaps?: boolean | undefined;
installCommand?: string | null | undefined;
name?: string | undefined;
nodeVersion?: string | undefined;
outputDirectory?: string | null | undefined;
previewDeploymentsDisabled?: boolean | null | undefined;
previewDeploymentSuffix?: string | null | undefined;
resourceConfig?: UpdateProjectResourceConfig$Outbound | undefined;
publicSource?: boolean | null | undefined;
rootDirectory?: string | null | undefined;
serverlessFunctionRegion?: string | null | undefined;
serverlessFunctionZeroConfigFailover?: boolean | undefined;
skewProtectionBoundaryAt?: number | undefined;
skewProtectionMaxAge?: number | undefined;
skewProtectionAllowedDomains?: Array<string> | undefined;
skipGitConnectDuringLink?: boolean | undefined;
sourceFilesOutsideRootDirectory?: boolean | undefined;
enablePreviewFeedback?: boolean | null | undefined;
enableProductionFeedback?: boolean | null | undefined;
enableAffectedProjectsDeployments?: boolean | undefined;
enableExternalRewriteCaching?: boolean | undefined;
staticIps?: UpdateProjectStaticIps$Outbound | undefined;
tracing?: UpdateProjectTracing$Outbound | null | undefined;
oidcTokenConfig?: UpdateProjectOidcTokenConfig$Outbound | undefined;
passwordProtection?: UpdateProjectPasswordProtection$Outbound | null | undefined;
passport?: UpdateProjectPassport$Outbound | null | undefined;
sandbox?: UpdateProjectSandbox$Outbound | undefined;
ssoProtection?: UpdateProjectSsoProtection$Outbound | null | undefined;
trustedIps?: UpdateProjectTrustedIps$Outbound | null | undefined;
trustedSources?: TrustedSources$Outbound | null | undefined;
deploymentPolicy?: DeploymentPolicy1$Outbound | string | undefined;
optionsAllowlist?: UpdateProjectOptionsAllowlist$Outbound | null | undefined;
connectConfigurations?: Array<ConnectConfigurations1$Outbound> | null | undefined;
dismissedToasts?: Array<UpdateProjectDismissedToasts$Outbound> | undefined;
};
/** @internal */
export declare const UpdateProjectRequestBody$outboundSchema: z.ZodType<UpdateProjectRequestBody$Outbound, z.ZodTypeDef, UpdateProjectRequestBody>;
export declare function updateProjectRequestBodyToJSON(updateProjectRequestBody: UpdateProjectRequestBody): string;
/** @internal */
export type UpdateProjectRequest$Outbound = {
idOrName: string;
teamId?: string | undefined;
slug?: string | undefined;
RequestBody: UpdateProjectRequestBody$Outbound;
};
/** @internal */
export declare const UpdateProjectRequest$outboundSchema: z.ZodType<UpdateProjectRequest$Outbound, z.ZodTypeDef, UpdateProjectRequest>;
export declare function updateProjectRequestToJSON(updateProjectRequest: UpdateProjectRequest): string;
/** @internal */
export declare const UpdateProjectCreator4$inboundSchema: z.ZodType<UpdateProjectCreator4, z.ZodTypeDef, unknown>;
export declare function updateProjectCreator4FromJSON(jsonString: string): SafeParseResult<UpdateProjectCreator4, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreatorIntegration$inboundSchema: z.ZodType<UpdateProjectCreatorIntegration, z.ZodTypeDef, unknown>;
export declare function updateProjectCreatorIntegrationFromJSON(jsonString: string): SafeParseResult<UpdateProjectCreatorIntegration, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreator3$inboundSchema: z.ZodType<UpdateProjectCreator3, z.ZodTypeDef, unknown>;
export declare function updateProjectCreator3FromJSON(jsonString: string): SafeParseResult<UpdateProjectCreator3, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreatorApp$inboundSchema: z.ZodType<UpdateProjectCreatorApp, z.ZodTypeDef, unknown>;
export declare function updateProjectCreatorAppFromJSON(jsonString: string): SafeParseResult<UpdateProjectCreatorApp, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreator2$inboundSchema: z.ZodType<UpdateProjectCreator2, z.ZodTypeDef, unknown>;
export declare function updateProjectCreator2FromJSON(jsonString: string): SafeParseResult<UpdateProjectCreator2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectViaIntegration$inboundSchema: z.ZodType<UpdateProjectViaIntegration, z.ZodTypeDef, unknown>;
export declare function updateProjectViaIntegrationFromJSON(jsonString: string): SafeParseResult<UpdateProjectViaIntegration, SDKValidationError>;
/** @internal */
export declare const UpdateProjectVia2$inboundSchema: z.ZodType<UpdateProjectVia2, z.ZodTypeDef, unknown>;
export declare function updateProjectVia2FromJSON(jsonString: string): SafeParseResult<UpdateProjectVia2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectViaApp$inboundSchema: z.ZodType<UpdateProjectViaApp, z.ZodTypeDef, unknown>;
export declare function updateProjectViaAppFromJSON(jsonString: string): SafeParseResult<UpdateProjectViaApp, SDKValidationError>;
/** @internal */
export declare const UpdateProjectVia1$inboundSchema: z.ZodType<UpdateProjectVia1, z.ZodTypeDef, unknown>;
export declare function updateProjectVia1FromJSON(jsonString: string): SafeParseResult<UpdateProjectVia1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreatorVia$inboundSchema: z.ZodType<UpdateProjectCreatorVia, z.ZodTypeDef, unknown>;
export declare function updateProjectCreatorViaFromJSON(jsonString: string): SafeParseResult<UpdateProjectCreatorVia, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreatorUser$inboundSchema: z.ZodType<UpdateProjectCreatorUser, z.ZodTypeDef, unknown>;
export declare function updateProjectCreatorUserFromJSON(jsonString: string): SafeParseResult<UpdateProjectCreatorUser, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreator1$inboundSchema: z.ZodType<UpdateProjectCreator1, z.ZodTypeDef, unknown>;
export declare function updateProjectCreator1FromJSON(jsonString: string): SafeParseResult<UpdateProjectCreator1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCreator$inboundSchema: z.ZodType<UpdateProjectCreator, z.ZodTypeDef, unknown>;
export declare function updateProjectCreatorFromJSON(jsonString: string): SafeParseResult<UpdateProjectCreator, SDKValidationError>;
/** @internal */
export declare const UpdateProjectConfiguredBy$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectConfiguredBy>;
/** @internal */
export declare const UpdateProjectProjectsResponseAliasAssigned$inboundSchema: z.ZodType<UpdateProjectProjectsResponseAliasAssigned, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponseAliasAssignedFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponseAliasAssigned, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponseAliasError$inboundSchema: z.ZodType<UpdateProjectProjectsResponseAliasError, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponseAliasErrorFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponseAliasError, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType>;
/** @internal */
export declare const UpdateProjectProjectsResponse200BranchMatcher$inboundSchema: z.ZodType<UpdateProjectProjectsResponse200BranchMatcher, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponse200BranchMatcherFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponse200BranchMatcher, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponseBuilds$inboundSchema: z.ZodType<UpdateProjectProjectsResponseBuilds, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponseBuildsFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponseBuilds, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponseChecksConclusion$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponseChecksConclusion>;
/** @internal */
export declare const UpdateProjectProjectsResponseChecksState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponseChecksState>;
/** @internal */
export declare const UpdateProjectProjectsResponse200Creator$inboundSchema: z.ZodType<UpdateProjectProjectsResponse200Creator, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponse200CreatorFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponse200Creator, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponseOidcTokenClaims$inboundSchema: z.ZodType<UpdateProjectProjectsResponseOidcTokenClaims, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsResponseOidcTokenClaimsFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsResponseOidcTokenClaims, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponsePlan$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponsePlan>;
/** @internal */
export declare const UpdateProjectProjectsResponseReadyState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponseReadyState>;
/** @internal */
export declare const UpdateProjectProjectsResponseReadySubstate$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponseReadySubstate>;
/** @internal */
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyAliasType>;
/** @internal */
export declare const UpdateProjectDeployment$inboundSchema: z.ZodType<UpdateProjectDeployment, z.ZodTypeDef, unknown>;
export declare function updateProjectDeploymentFromJSON(jsonString: string): SafeParseResult<UpdateProjectDeployment, SDKValidationError>;
/** @internal */
export declare const UpdateProjectEnvironment$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectEnvironment>;
/** @internal */
export declare const UpdateProjectTarget$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectTarget>;
/** @internal */
export declare const UpdateProjectAlias$inboundSchema: z.ZodType<UpdateProjectAlias, z.ZodTypeDef, unknown>;
export declare function updateProjectAliasFromJSON(jsonString: string): SafeParseResult<UpdateProjectAlias, SDKValidationError>;
/** @internal */
export declare const UpdateProjectAnalytics$inboundSchema: z.ZodType<UpdateProjectAnalytics, z.ZodTypeDef, unknown>;
export declare function updateProjectAnalyticsFromJSON(jsonString: string): SafeParseResult<UpdateProjectAnalytics, SDKValidationError>;
/** @internal */
export declare const UpdateProjectSpeedInsights$inboundSchema: z.ZodType<UpdateProjectSpeedInsights, z.ZodTypeDef, unknown>;
export declare function updateProjectSpeedInsightsFromJSON(jsonString: string): SafeParseResult<UpdateProjectSpeedInsights, SDKValidationError>;
/** @internal */
export declare const UpdateProjectEnvId2$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectEnvId2>;
/** @internal */
export declare const UpdateProjectEnvId$inboundSchema: z.ZodType<UpdateProjectEnvId, z.ZodTypeDef, unknown>;
export declare function updateProjectEnvIdFromJSON(jsonString: string): SafeParseResult<UpdateProjectEnvId, SDKValidationError>;
/** @internal */
export declare const UpdateProjectAws$inboundSchema: z.ZodType<UpdateProjectAws, z.ZodTypeDef, unknown>;
export declare function updateProjectAwsFromJSON(jsonString: string): SafeParseResult<UpdateProjectAws, SDKValidationError>;
/** @internal */
export declare const UpdateProjectConnectConfigurations$inboundSchema: z.ZodType<UpdateProjectConnectConfigurations, z.ZodTypeDef, unknown>;
export declare function updateProjectConnectConfigurationsFromJSON(jsonString: string): SafeParseResult<UpdateProjectConnectConfigurations, SDKValidationError>;
/** @internal */
export declare const UpdateProjectSource$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectSource>;
/** @internal */
export declare const UpdateProjectDefinitions$inboundSchema: z.ZodType<UpdateProjectDefinitions, z.ZodTypeDef, unknown>;
export declare function updateProjectDefinitionsFromJSON(jsonString: string): SafeParseResult<UpdateProjectDefinitions, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCrons$inboundSchema: z.ZodType<UpdateProjectCrons, z.ZodTypeDef, unknown>;
export declare function updateProjectCronsFromJSON(jsonString: string): SafeParseResult<UpdateProjectCrons, SDKValidationError>;
/** @internal */
export declare const UpdateProjectDataCache$inboundSchema: z.ZodType<UpdateProjectDataCache, z.ZodTypeDef, unknown>;
export declare function updateProjectDataCacheFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCache, SDKValidationError>;
/** @internal */
export declare const UpdateProjectDeploymentExpiration$inboundSchema: z.ZodType<UpdateProjectDeploymentExpiration, z.ZodTypeDef, unknown>;
export declare function updateProjectDeploymentExpirationFromJSON(jsonString: string): SafeParseResult<UpdateProjectDeploymentExpiration, SDKValidationError>;
/** @internal */
export declare const UpdateProjectExpiration2$inboundSchema: z.ZodType<UpdateProjectExpiration2, z.ZodTypeDef, unknown>;
export declare function updateProjectExpiration2FromJSON(jsonString: string): SafeParseResult<UpdateProjectExpiration2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectExpiration1$inboundSchema: z.ZodType<UpdateProjectExpiration1, z.ZodTypeDef, unknown>;
export declare function updateProjectExpiration1FromJSON(jsonString: string): SafeParseResult<UpdateProjectExpiration1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectExpiration$inboundSchema: z.ZodType<UpdateProjectExpiration, z.ZodTypeDef, unknown>;
export declare function updateProjectExpirationFromJSON(jsonString: string): SafeParseResult<UpdateProjectExpiration, SDKValidationError>;
/** @internal */
export declare const UpdateProjectTarget2$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectTarget2>;
/** @internal */
export declare const UpdateProjectProjectsTarget$inboundSchema: z.ZodType<UpdateProjectProjectsTarget, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsTargetFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsTarget, SDKValidationError>;
/** @internal */
export declare const UpdateProjectType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectType>;
/** @internal */
export declare const UpdateProjectVisibility$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectVisibility>;
/** @internal */
export declare const UpdateProjectContentHint17$inboundSchema: z.ZodType<UpdateProjectContentHint17, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint17FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint17, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint16$inboundSchema: z.ZodType<UpdateProjectContentHint16, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint16FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint16, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint15$inboundSchema: z.ZodType<UpdateProjectContentHint15, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint15FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint15, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint14$inboundSchema: z.ZodType<UpdateProjectContentHint14, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint14FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint14, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint13$inboundSchema: z.ZodType<UpdateProjectContentHint13, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint13FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint13, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint12$inboundSchema: z.ZodType<UpdateProjectContentHint12, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint12FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint12, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint11$inboundSchema: z.ZodType<UpdateProjectContentHint11, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint11FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint11, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint10$inboundSchema: z.ZodType<UpdateProjectContentHint10, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint10FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint10, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint9$inboundSchema: z.ZodType<UpdateProjectContentHint9, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint9FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint9, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint8$inboundSchema: z.ZodType<UpdateProjectContentHint8, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint8FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint8, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint7$inboundSchema: z.ZodType<UpdateProjectContentHint7, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint7FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint7, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint6$inboundSchema: z.ZodType<UpdateProjectContentHint6, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint6FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint6, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint5$inboundSchema: z.ZodType<UpdateProjectContentHint5, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint5FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint5, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint4$inboundSchema: z.ZodType<UpdateProjectContentHint4, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint4FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint4, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint3$inboundSchema: z.ZodType<UpdateProjectContentHint3, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint3FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint3, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint2$inboundSchema: z.ZodType<UpdateProjectContentHint2, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint2FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint1$inboundSchema: z.ZodType<UpdateProjectContentHint1, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHint1FromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectContentHint$inboundSchema: z.ZodType<UpdateProjectContentHint, z.ZodTypeDef, unknown>;
export declare function updateProjectContentHintFromJSON(jsonString: string): SafeParseResult<UpdateProjectContentHint, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyEnvType>;
/** @internal */
export declare const UpdateProjectInternalContentHint$inboundSchema: z.ZodType<UpdateProjectInternalContentHint, z.ZodTypeDef, unknown>;
export declare function updateProjectInternalContentHintFromJSON(jsonString: string): SafeParseResult<UpdateProjectInternalContentHint, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsEnv$inboundSchema: z.ZodType<UpdateProjectProjectsEnv, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsEnvFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsEnv, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsType>;
/** @internal */
export declare const UpdateProjectProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType>;
//# sourceMappingURL=updateprojectprojectsresponse200applicationjsonresponsebodycustomenvironmentstype.d.ts.map