@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,292 lines • 103 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 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 Vitepress: "vitepress";
readonly Vuepress: "vuepress";
readonly Parcel: "parcel";
readonly Fastapi: "fastapi";
readonly Flask: "flask";
readonly Fasthtml: "fasthtml";
readonly Django: "django";
readonly Ash: "ash";
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 Enhanced: "enhanced";
readonly Turbo: "turbo";
readonly Standard: "standard";
readonly Elastic: "elastic";
};
export type UpdateProjectBuildMachineType = ClosedEnum<typeof UpdateProjectBuildMachineType>;
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 UpdateProjectBuildMachineSelection: {
readonly Elastic: "elastic";
readonly Fixed: "fixed";
};
export type UpdateProjectBuildMachineSelection = ClosedEnum<typeof UpdateProjectBuildMachineSelection>;
/**
* Specifies resource override configuration for the project
*/
export type UpdateProjectResourceConfig = {
buildMachineType?: UpdateProjectBuildMachineType | 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;
buildMachineSelection?: UpdateProjectBuildMachineSelection | undefined;
buildMachineElasticLastUpdated?: number | 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>;
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 configuration for this project
*/
export type Tracing = {
/**
* 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;
};
/**
* 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 = {
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 UpdateProjectEnvironmentsProjects1 = {
type: "system";
target: UpdateProjectEnvironmentsProjectsTarget;
};
export type GitSourcesEnvironments = UpdateProjectEnvironmentsProjects1 | 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<UpdateProjectEnvironmentsProjects1 | 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 UpdateProjectEnvironments1 = {
type: "system";
target: UpdateProjectEnvironmentsTarget;
};
export type DeploymentSourcesEnvironments = UpdateProjectEnvironments1 | 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<UpdateProjectEnvironments1 | 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?: Tracing | 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;
/**
* 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 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;
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 UpdateProjectTarget = 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>;
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 UpdateProjectProjectsResponse200ApplicationJSONType: {
readonly FlagsSecret: "flags-secret";
};
export type UpdateProjectProjectsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONType>;
/**
* Similar to `contentHints`, but should not be exposed to the user.
*/
export type UpdateProjectInternalContentHint = {
type: UpdateProjectProjectsResponse200ApplicationJSONType;
/**
* 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;
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 UpdateProjectProjectsResponse200Type: {
readonly EndsWith: "endsWith";
readonly Equals: "equals";
readonly StartsWith: "startsWith";
};
/**
* The type of matching to perform
*/
export type UpdateProjectProjectsResponse200Type = ClosedEnum<typeof UpdateProjectProjectsResponse200Type>;
/**
* Configuration for matching git branches to this environment
*/
export type UpdateProjectBranchMatcher = {
/**
* The type of matching to perform
*/
type: UpdateProjectProjectsResponse200Type;
/**
* The pattern to match against branch names
*/
pattern: string;
};
/**
* A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
*/
export type UpdateProjectVerification = {
type: string;
domain: string;
value: string;
reason: string;
};
/**
* List of domains associated with this environment
*/
export type UpdateProjectDomains = {
name: string;
apexName: string;
projectId: string;
redirect?: string | null | undefined;
redirectStatusCode?: number | null | undefined;
gitBranch?: string | null | undefined;
customEnvironmentId?: string | null | undefined;
updatedAt?: number | undefined;
createdAt?: number | undefined;
/**
* `true` if the domain is verified for use with the project. If `false` it will not be used as an alias on this project until the challenge in `verification` is completed.
*/
verified: boolean;
/**
* A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
*/
verification?: Array<UpdateProjectVerification> | undefined;
};
/**
* Internal representation of a custom environment with all required properties
*/
export type UpdateProjectCustomEnvironments = {
/**
* Unique identifier for the custom environment (format: env_*)
*/
id: string;
/**
* URL-friendly name of the environment
*/
slug: string;
/**
* The type of environment (production, preview, or development)
*/
type: UpdateProjectProjectsType;
/**
* Optional description of the environment's purpose
*/
description?: string | undefined;
/**
* Configuration for matching git branches to this environment
*/
branchMatcher?: UpdateProjectBranchMatcher | undefined;
/**
* List of domains associated with this environment
*/
domains?: Array<UpdateProjectDomains> | undefined;
/**
* List of aliases for the current deployment
*/
currentDeploymentAliases?: Array<string> | undefined;
/**
* Timestamp when the environment was created
*/
createdAt: number;
/**
* Timestamp when the environment was last updated
*/
updatedAt: number;
};
export declare const UpdateProjectProjectsFramework: {
readonly ActixWeb: "actix-web";
readonly Angular: "angular";
readonly Ash: "ash";
readonly Astro: "astro";
readonly Axum: "axum";
readonly Blitzjs: "blitzjs";
readonly Brunch: "brunch";
readonly Bun: "bun";
readonly CreateReactApp: "create-react-app";
readonly Django: "django";
readonly Docusaurus: "docusaurus";
readonly Docusaurus2: "docusaurus-2";
readonly Dojo: "dojo";
readonly Eleventy: "eleventy";
readonly Elysia: "elysia";
readonly Ember: "ember";
readonly Eve: "eve";
readonly Express: "express";
readonly Fastapi: "fastapi";
readonly Fasthtml: "fasthtml";
readonly Fastify: "fastify";
readonly Flask: "flask";
readonly Gatsby: "gatsby";
readonly Go: "go";
readonly Gridsome: "gridsome";
readonly H3: "h3";
readonly Hexo: "hexo";
readonly Hono: "hono";
readonly Hugo: "hugo";
readonly Hydrogen: "hydrogen";
readonly IonicAngular: "ionic-angular";
readonly IonicReact: "ionic-react";
readonly Jekyll: "jekyll";
readonly Koa: "koa";
readonly Mastra: "mastra";
readonly Middleman: "middleman";
readonly Nestjs: "nestjs";
readonly Nextjs: "nextjs";
readonly Nitro: "nitro";
readonly Node: "node";
readonly Nuxtjs: "nuxtjs";
readonly Parcel: "parcel";
readonly Polymer: "polymer";
readonly Preact: "preact";
readonly Python: "python";
readonly ReactRouter: "react-router";
readonly Redwoodjs: "redwoodjs";
readonly Remix: "remix";
readonly Ruby: "ruby";
readonly Rust: "rust";
readonly Saber: "saber";
readonly Sanity: "sanity";
readonly SanityV2: "sanity-v2";
readonly Sapper: "sapper";
readonly Scully: "scully";
readonly Services: "services";
readonly Solidstart: "solidstart";
readonly Solidstart1: "solidstart-1";
readonly Stencil: "stencil";
readonly Storybook: "storybook";
readonly Svelte: "svelte";
readonly Sveltekit: "sveltekit";
readonly Sveltekit1: "sveltekit-1";
readonly TanstackStart: "tanstack-start";
readonly Umijs: "umijs";
readonly Vite: "vite";
readonly Vitepress: "vitepress";
readonly Vue: "vue";
readonly Vuepress: "vuepress";
readonly Xmcp: "xmcp";
readonly Zola: "zola";
};
export type UpdateProjectProjectsFramework = ClosedEnum<typeof UpdateProjectProjectsFramework>;
/**
* Service kind (Service.type). Omitted for schemas that do not define one.
*/
export declare const UpdateProjectServiceType: {
readonly Cron: "cron";
readonly Job: "job";
readonly Web: "web";
readonly Worker: "worker";
};
/**
* Service kind (Service.type). Omitted for schemas that do not define one.
*/
export type UpdateProjectServiceType = ClosedEnum<typeof UpdateProjectServiceType>;
/**
* Framework slug, when the service has one (omitted otherwise).
*/
export declare const UpdateProjectProjectsResponseFramework: {
readonly ActixWeb: "actix-web";
readonly Angular: "angular";
readonly Ash: "ash";
readonly Astro: "astro";
readonly Axum: "axum";
readonly Blitzjs: "blitzjs";
readonly Brunch: "brunch";
readonly Bun: "bun";
readonly CreateReactApp: "create-react-app";
readonly Django: "django";
readonly Docusaurus: "docusaurus";
readonly Docusaurus2: "docusaurus-2";
readonly Dojo: "dojo";
readonly Eleventy: "eleventy";
readonly Elysia: "elysia";
readonly Ember: "ember";
readonly Eve: "eve";
readonly Express: "express";
readonly Fastapi: "fastapi";
readonly Fasthtml: "fasthtml";
readonly Fastify: "fastify";
readonly Flask: "flask";
readonly Gatsby: "gatsby";
readonly Go: "go";
readonly Gridsome: "gridsome";
readonly H3: "h3";
readonly Hexo: "hexo";
readonly Hono: "hono";
readonly Hugo: "hugo";
readonly Hydrogen: "hydrogen";
readonly IonicAngular: "ionic-angular";
readonly IonicReact: "ionic-react";
readonly Jekyll: "jekyll";
readonly Koa: "koa";
readonly Mastra: "mastra";
readonly Middleman: "middleman";
readonly Nestjs: "nestjs";
readonly Nextjs: "nextjs";
readonly Nitro: "nitro";
readonly Node: "node";
readonly Nuxtjs: "nuxtjs";
readonly Parcel: "parcel";
readonly Polymer: "polymer";
readonly Preact: "preact";
readonly Python: "python";
readonly ReactRouter: "react-router";
readonly Redwoodjs: "redwoodjs";
readonly Remix: "remix";
readonly Ruby: "ruby";
readonly Rust: "rust";
readonly Saber: "saber";
readonly Sanity: "sanity";
readonly SanityV2: "sanity-v2";
readonly Sapper: "sapper";
readonly Scully: "scully";
readonly Services: "services";
readonly Solidstart: "solidstart";
readonly Solidstart1: "solidstart-1";
readonly Stencil: "stencil";
readonly Storybook: "storybook";
readonly Svelte: "svelte";
readonly Sveltekit: "sveltekit";
readonly Sveltekit1: "sveltekit-1";
readonly TanstackStart: "tanstack-start";
readonly Umijs: "umijs";
readonly Vite: "vite";
readonly Vitepress: "vitepress";
readonly Vue: "vue";
readonly Vuepress: "vuepress";
readonly Xmcp: "xmcp";
readonly Zola: "zola";
};
/**
* Framework slug, when the service has one (omitted otherwise).
*/
export type UpdateProjectProjectsResponseFramework = ClosedEnum<typeof UpdateProjectProjectsResponseFramework>;
export type UpdateProjectServices = {
/**
* Service name from the deployment (Service.name).
*/
serviceName: string;
/**
* Service kind (Service.type). Omitted for schemas that do not define one.
*/
serviceType?: UpdateProjectServiceType | undefined;
/**
* Framework slug, when the service has one (omitted otherwise).
*/
framework?: UpdateProjectProjectsResponseFramework | undefined;
/**
* Generic runtime, e.g. 'node' | 'python' | 'go' | 'ruby' | 'rust' (Service.runtime). Omitted for static builds.
*/
runtime?: string | undefined;
};
export type UpdateProjectIpBuckets = {
bucket: string;
default?: boolean | undefined;
supportUntil?: number | undefined;
};
export type UpdateProjectLint = {
targets: Array<string>;
};
export type UpdateProjectTypecheck = {
targets: Array<string>;
};
export type UpdateProjectMfeConfigPresent = {
targets: Array<string>;
};
export type UpdateProjectJobs = {
lint?: UpdateProjectLint | undefined;
typecheck?: UpdateProjectTypecheck | undefined;
mfeConfigPresent?: UpdateProjectMfeConfigPresent | undefined;
};
export type UpdateProjectAliasAssigned = number | boolean;
export type UpdateProjectBuilds = {
use: string;
src?: string | undefined;
dest?: string | undefined;
};
export type UpdateProjectCreator = {
email: string;
githubLogin?: string | undefined;
gitlabLogin?: string | undefined;
uid: string;
username: string;
};
export type UpdateProjectLatestDeployments = {
alias?: Array<string> | undefined;
aliasAssigned?: number | boolean | null | undefined;
builds?: Array<UpdateProjectBuilds> | undefined;
createdAt: number;
createdIn: string;
creator: UpdateProjectCreator | null;
deploymentHostname: string;
name: string;
forced?: boolean | undefined;
id: string;
meta?: {
[k: string]: string;
} | undefined;
plan: string;
private: boolean;
readyState: string;
requestedAt?: number | undefined;
target?: string | null | undefined;
teamId?: string | null | undefined;
type: string;
url: string;
userId: string;
withCache?: boolean | undefined;
};
export type UpdateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink6 = {
org: string;
repo: string;
type: "vercel";
createdAt?: number | undefined;
deployHooks: Array<UpdateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks>;
gitCredentialId: string;
updatedAt?: number | undefined;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLinkProjectsResponse200ApplicationJSONDeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink5 = {
name: string;
slug: string;
owner: string;
type: "bitbucket";
uuid: string;
workspaceUuid: string;
createdAt?: number | undefined;
deployHooks: Array<UpdateProjectLinkProjectsResponse200ApplicationJSONDeployHooks>;
gitCredentialId: string;
updatedAt?: number | undefined;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLinkProjectsResponse200DeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink4 = {
projectId: string;
projectName: string;
projectNameWithNamespace: string;
projectNamespace: string;
/**
* A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes. This is the id of the top level group that a namespace belongs to. Gitlab supports group nesting (up to 20 levels).
*/
projectOwnerId?: number | undefined;
projectUrl: string;
type: "gitlab";
createdAt?: number | undefined;
deployHooks: Array<UpdateProjectLinkProjectsResponse200DeployHooks>;
gitCredentialId: string;
updatedAt?: number | undefined;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLinkProjectsResponseDeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink3 = {
org: string;
/**
* A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
*/
repoOwnerId?: number | undefined;
repo?: string | undefined;
repoId?: number | undefined;
type: "github-custom-host";
host: string;
createdAt?: number | undefined;
deployHooks: Array<UpdateProjectLinkProjectsResponseDeployHooks>;
gitCredentialId: string;
updatedAt?: number | undefined;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLinkProjectsDeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink2 = {
type: "github-limited";
repo?: string | undefined;
repoId?: number | undefined;
createdAt?: number | undefined;
updatedAt?: number | undefined;
org: string;
/**
* A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
*/
repoOwnerId?: number | undefined;
deployHooks: Array<UpdateProjectLinkProjectsDeployHooks>;
gitCredentialId: string;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLinkDeployHooks = {
createdAt?: number | undefined;
id: string;
name: string;
ref: string;
url: string;
};
export type UpdateProjectLink1 = {
org: string;
/**
* A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
*/
repoOwnerId?: number | undefined;
repo?: string | undefined;
repoId?: number | undefined;
type: "github";
createdAt?: number | undefined;
deployHooks: Array<UpdateProjectLinkDeployHooks>;
gitCredentialId: string;
updatedAt?: number | undefined;
sourceless?: boolean | undefined;
productionBranch: string;
};
export type UpdateProjectLink = UpdateProjectLink1 | UpdateProjectLink2 | UpdateProjectLink3 | UpdateProjectLink4 | UpdateProjectLink5 | UpdateProjectLink6;
export type UpdateProjectMicrofrontends3 = {
updatedAt: number;
groupIds: Array<any>;
enabled: false;
freeProjectForLegacyLimits?: boolean | undefined;
};
export type UpdateProjectMicrofrontends2 = {
isDefaultApp?: false | undefined;
/**
* Whether observability data should be routed to this microfrontend project or a root project.
*/
routeObservabilityToThisProject?: boolean | undefined;
/**
* Whether to add microfrontends routing to aliases. This means domains in this project will route as a microfrontend.
*/
doNotRouteWithMicrofrontendsRouting?: boolean | undefined;
/**
* Timestamp when the microfrontends settings were last updated.
*/
updatedAt: number;
/**
* The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
*/
groupIds: Array<string>;
/**
* Whether microfrontends are enabled for this project.
*/
enabled: true;
/**
* A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
*/
defaultRoute?: string | undefined;
/**
* Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
*/
freeProjectForLegacyLimits?: boolean | undefined;
};
export type UpdateProjectMicrofrontends1 = {
isDefaultApp: true;
/**
* Timestamp when the microfrontends settings were last updated.
*/
updatedAt: number;
/**
* The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
*/
groupIds: Array<string>;
/**
* Whether microfrontends are enabled for this project.
*/
enabled: true;
/**
* A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
*/
defaultRoute?: string | undefined;
/**
* Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
*/
freeProjectForLegacyLimits?: boolean | undefined;
};
export type UpdateProjectMicrofrontends = UpdateProjectMicrofrontends1 | UpdateProjectMicrofrontends2 | UpdateProjectMicrofrontends3;
export declare const UpdateProjectProjectsNodeVersion: {
readonly TenDotX: "10.x";
readonly TwelveDotX: "12.x";
readonly FourteenDotX: "14.x";
readonly SixteenDotX: "16.x";
readonly EighteenDotX: "18.x";
readonly TwentyDotX: "20.x";
readonly TwentyTwoDotX: "22.x";
readonly TwentyFourDotX: "24.x";
readonly EightDot10DotX: "8.10.x";
};
export type UpdateProjectProjectsNodeVersion = ClosedEnum<typeof UpdateProjectProjectsNodeVersion>;
export type UpdateProjectProjectsPaths = {
value: string;
};
export type UpdateProjectProjectsOptionsAllowlist = {
paths: Array<UpdateProjectProjectsPaths>;
};
/** @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 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 UpdateProjectBuildMachineSelection$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectBuildMachineSelection>;
/** @internal */
export type UpdateProjectResourceConfig$Outbound = {
buildMachineType?: 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;
buildMachineSelection?: string | undefined;
buildMachineElasticLastUpdated?: number | 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 type SamplingRules$Outbound = {
rate: number;
env?: string | undefined;
requestPath?: 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 Tracing$Outbound = {
domains?: string | undefined;
ignorePaths?: Array<string> | undefined;
samplingRules?: Array<SamplingRules$Outbound> | undefined;
};
/** @internal */
export declare const Tracing$outboundSchema: z.ZodType<Tracing$Outbound, z.ZodTypeDef, Tracing>;
export declare function tracingToJSON(tracing: Tracing): 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 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 = {
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 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 GitSourcesEnvironments$Outbound = UpdateProjectEnvironmentsProjects1$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<UpdateProjectEnvironmentsProjects1$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 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 DeploymentSourcesEnvironments$Outbound = UpdateProjectEnvironments1$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<UpdateProjectEnvironments1$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?: Tracing$Outbound | null | undefined;
oidcTokenConfig?: UpdateProjectOidcTokenConfig$Outbound | undefined;
passwordProtection?: UpdateProjectPasswordProtection$Outbound | null | undefined;
passport?: UpdateProjectPassport$Outbound | null | 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 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 UpdateProjectTarget$inboundSchema: z.ZodType<UpdateProjectTarget, z.ZodTypeDef, unknown>;
export declare function updateProjectTargetFromJSON(jsonString: string): SafeParseResult<UpdateProjectTarget, SDKValidationError>;
/** @internal */
export declare const UpdateProjectType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectType>;
/** @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 UpdateProjectProjectsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200ApplicationJSONType>;
/** @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 UpdateProjectProjectsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponse200Type>;
/** @internal */
export declare const UpdateProjectBranchMatcher$inboundSchema: z.ZodType<UpdateProjectBranchMatcher, z.ZodTypeDef, unknown>;
export declare function updateProjectBranchMatcherFromJSON(jsonString: string): SafeParseResult<UpdateProjectBranchMatcher, SDKValidationError>;
/** @internal */
export declare const UpdateProjectVerification$inboundSchema: z.ZodType<UpdateProjectVerification, z.ZodTypeDef, unknown>;
export declare function updateProjectVerificationFromJSON(jsonString: string): SafeParseResult<UpdateProjectVerification, SDKValidationError>;
/** @internal */
export declare const UpdateProjectDomains$inboundSchema: z.ZodType<UpdateProjectDomains, z.ZodTypeDef, unknown>;
export declare function updateProjectDomainsFromJSON(jsonString: string): SafeParseResult<UpdateProjectDomains, SDKValidationError>;
/** @internal */
export declare const UpdateProjectCustomEnvironments$inboundSchema: z.ZodType<UpdateProjectCustomEnvironments, z.ZodTypeDef, unknown>;
export declare function updateProjectCustomEnvironmentsFromJSON(jsonString: string): SafeParseResult<UpdateProjectCustomEnvironments, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsFramework$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsFramework>;
/** @internal */
export declare const UpdateProjectServiceType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectServiceType>;
/** @internal */
export declare const UpdateProjectProjectsResponseFramework$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsResponseFramework>;
/** @internal */
export declare const UpdateProjectServices$inboundSchema: z.ZodType<UpdateProjectServices, z.ZodTypeDef, unknown>;
export declare function updateProjectServicesFromJSON(jsonString: string): SafeParseResult<UpdateProjectServices, SDKValidationError>;
/** @internal */
export declare const UpdateProjectIpBuckets$inboundSchema: z.ZodType<UpdateProjectIpBuckets, z.ZodTypeDef, unknown>;
export declare function updateProjectIpBucketsFromJSON(jsonString: string): SafeParseResult<UpdateProjectIpBuckets, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLint$inboundSchema: z.ZodType<UpdateProjectLint, z.ZodTypeDef, unknown>;
export declare function updateProjectLintFromJSON(jsonString: string): SafeParseResult<UpdateProjectLint, SDKValidationError>;
/** @internal */
export declare const UpdateProjectTypecheck$inboundSchema: z.ZodType<UpdateProjectTypecheck, z.ZodTypeDef, unknown>;
export declare function updateProjectTypecheckFromJSON(jsonString: string): SafeParseResult<UpdateProjectTypecheck, SDKValidationError>;
/** @internal */
export declare const UpdateProjectMfeConfigPresent$inboundSchema: z.ZodType<UpdateProjectMfeConfigPresent, z.ZodTypeDef, unknown>;
export declare function updateProjectMfeConfigPresentFromJSON(jsonString: string): SafeParseResult<UpdateProjectMfeConfigPresent, SDKValidationError>;
/** @internal */
export declare const UpdateProjectJobs$inboundSchema: z.ZodType<UpdateProjectJobs, z.ZodTypeDef, unknown>;
export declare function updateProjectJobsFromJSON(jsonString: string): SafeParseResult<UpdateProjectJobs, SDKValidationError>;
/** @internal */
export declare const UpdateProjectAliasAssigned$inboundSchema: z.ZodType<UpdateProjectAliasAssigned, z.ZodTypeDef, unknown>;
export declare function updateProjectAliasAssignedFromJSON(jsonString: string): SafeParseResult<UpdateProjectAliasAssigned, SDKValidationError>;
/** @internal */
export declare const UpdateProjectBuilds$inboundSchema: z.ZodType<UpdateProjectBuilds, z.ZodTypeDef, unknown>;
export declare function updateProjectBuildsFromJSON(jsonString: string): SafeParseResult<UpdateProjectBuilds, 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 UpdateProjectLatestDeployments$inboundSchema: z.ZodType<UpdateProjectLatestDeployments, z.ZodTypeDef, unknown>;
export declare function updateProjectLatestDeploymentsFromJSON(jsonString: string): SafeParseResult<UpdateProjectLatestDeployments, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink6$inboundSchema: z.ZodType<UpdateProjectLink6, z.ZodTypeDef, unknown>;
export declare function updateProjectLink6FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink6, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkProjectsResponse200ApplicationJSONDeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkProjectsResponse200ApplicationJSONDeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkProjectsResponse200ApplicationJSONDeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink5$inboundSchema: z.ZodType<UpdateProjectLink5, z.ZodTypeDef, unknown>;
export declare function updateProjectLink5FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink5, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkProjectsResponse200DeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkProjectsResponse200DeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkProjectsResponse200DeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkProjectsResponse200DeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink4$inboundSchema: z.ZodType<UpdateProjectLink4, z.ZodTypeDef, unknown>;
export declare function updateProjectLink4FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink4, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkProjectsResponseDeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkProjectsResponseDeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkProjectsResponseDeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkProjectsResponseDeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink3$inboundSchema: z.ZodType<UpdateProjectLink3, z.ZodTypeDef, unknown>;
export declare function updateProjectLink3FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink3, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkProjectsDeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkProjectsDeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkProjectsDeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkProjectsDeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink2$inboundSchema: z.ZodType<UpdateProjectLink2, z.ZodTypeDef, unknown>;
export declare function updateProjectLink2FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLinkDeployHooks$inboundSchema: z.ZodType<UpdateProjectLinkDeployHooks, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkDeployHooksFromJSON(jsonString: string): SafeParseResult<UpdateProjectLinkDeployHooks, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink1$inboundSchema: z.ZodType<UpdateProjectLink1, z.ZodTypeDef, unknown>;
export declare function updateProjectLink1FromJSON(jsonString: string): SafeParseResult<UpdateProjectLink1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectLink$inboundSchema: z.ZodType<UpdateProjectLink, z.ZodTypeDef, unknown>;
export declare function updateProjectLinkFromJSON(jsonString: string): SafeParseResult<UpdateProjectLink, SDKValidationError>;
/** @internal */
export declare const UpdateProjectMicrofrontends3$inboundSchema: z.ZodType<UpdateProjectMicrofrontends3, z.ZodTypeDef, unknown>;
export declare function updateProjectMicrofrontends3FromJSON(jsonString: string): SafeParseResult<UpdateProjectMicrofrontends3, SDKValidationError>;
/** @internal */
export declare const UpdateProjectMicrofrontends2$inboundSchema: z.ZodType<UpdateProjectMicrofrontends2, z.ZodTypeDef, unknown>;
export declare function updateProjectMicrofrontends2FromJSON(jsonString: string): SafeParseResult<UpdateProjectMicrofrontends2, SDKValidationError>;
/** @internal */
export declare const UpdateProjectMicrofrontends1$inboundSchema: z.ZodType<UpdateProjectMicrofrontends1, z.ZodTypeDef, unknown>;
export declare function updateProjectMicrofrontends1FromJSON(jsonString: string): SafeParseResult<UpdateProjectMicrofrontends1, SDKValidationError>;
/** @internal */
export declare const UpdateProjectMicrofrontends$inboundSchema: z.ZodType<UpdateProjectMicrofrontends, z.ZodTypeDef, unknown>;
export declare function updateProjectMicrofrontendsFromJSON(jsonString: string): SafeParseResult<UpdateProjectMicrofrontends, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsNodeVersion$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectProjectsNodeVersion>;
/** @internal */
export declare const UpdateProjectProjectsPaths$inboundSchema: z.ZodType<UpdateProjectProjectsPaths, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsPathsFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsPaths, SDKValidationError>;
/** @internal */
export declare const UpdateProjectProjectsOptionsAllowlist$inboundSchema: z.ZodType<UpdateProjectProjectsOptionsAllowlist, z.ZodTypeDef, unknown>;
export declare function updateProjectProjectsOptionsAllowlistFromJSON(jsonString: string): SafeParseResult<UpdateProjectProjectsOptionsAllowlist, SDKValidationError>;
//# sourceMappingURL=updateprojectprojectsoptionsallowlist.d.ts.map