@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Vercel API
@base https://api.vercel.com
@version 0.0.1
@auth Bearer bearer | OAuth2
@endpoints 322
@hint download_for_search
@toc access-groups(11), artifacts(6), billing(3), bulk-redirects(7), projects(75), deployments(21), connect(5), domains(10), registrar(16), log-drains(4), drains(6), edge-cache(4), edge-config(17), env(6), events(2), teams(18), integrations(12), installations(23), microfrontends(5), observability(2), sandboxes(40), security(9), storage(1), files(1), user(6), webhooks(4), aliases(4), certs(4)

@group access-groups
@endpoint GET /v1/access-groups/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {teamPermissions: [str], entitlements: [str], isDsyncManaged: bool, name: str, createdAt: str, teamId: str, updatedAt: str, accessGroupId: str, membersCount: num, projectsCount: num, teamRoles: [str]}
@errors {400, 401, 403}

@endpoint POST /v1/access-groups/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str, name: str, projects: [map{projectId!: str, role!: str}], membersToAdd: [str], membersToRemove: [str]}
@returns(200) {entitlements: [str], name: str, createdAt: str, teamId: str, updatedAt: str, accessGroupId: str, membersCount: num, projectsCount: num, teamRoles: [str], teamPermissions: [str]}
@errors {400, 401, 403}

@endpoint DELETE /v1/access-groups/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/access-groups/{idOrName}/members
@required {idOrName: str}
@optional {limit: int, next: str, search: str, teamId: str, slug: str}
@returns(200) {members: [map], pagination: map{count: num, next: str?}}
@errors {400, 401, 403}

@endpoint GET /v1/access-groups
@optional {projectId: str, search: str, membersLimit: int, projectsLimit: int, limit: int, next: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v1/access-groups
@required {name: str}
@optional {teamId: str, slug: str, projects: [map{projectId!: str, role!: str}], membersToAdd: [str]}
@returns(200) {entitlements: [str], membersCount: num, projectsCount: num, name: str, createdAt: str, teamId: str, updatedAt: str, accessGroupId: str, teamRoles: [str], teamPermissions: [str]}
@errors {400, 401, 403}

@endpoint GET /v1/access-groups/{idOrName}/projects
@required {idOrName: str}
@optional {limit: int, next: str, teamId: str, slug: str}
@returns(200) {projects: [map], pagination: map{count: num, next: str?}}
@errors {400, 401, 403}

@endpoint POST /v1/access-groups/{accessGroupIdOrName}/projects
@required {accessGroupIdOrName: str, projectId: str, role: str(ADMIN/PROJECT_VIEWER/PROJECT_DEVELOPER)}
@optional {teamId: str, slug: str}
@returns(200) {teamId: str, accessGroupId: str, projectId: str, role: str, createdAt: str, updatedAt: str}
@errors {400, 401, 403}

@endpoint GET /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}
@required {accessGroupIdOrName: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {teamId: str, accessGroupId: str, projectId: str, role: str, createdAt: str, updatedAt: str}
@errors {400, 401, 403}

@endpoint PATCH /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}
@required {accessGroupIdOrName: str, projectId: str, role: str(ADMIN/PROJECT_VIEWER/PROJECT_DEVELOPER)}
@optional {teamId: str, slug: str}
@returns(200) {teamId: str, accessGroupId: str, projectId: str, role: str, createdAt: str, updatedAt: str}
@errors {400, 401, 403}

@endpoint DELETE /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}
@required {accessGroupIdOrName: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endgroup

@group artifacts
@endpoint POST /v8/artifacts/events
@optional {x-artifact-client-ci: str, x-artifact-client-interactive: int, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403}

@endpoint GET /v8/artifacts/status
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403}

@endpoint PUT /v8/artifacts/{hash}
@required {Content-Length: num, hash: str}
@optional {x-artifact-duration: num, x-artifact-client-ci: str, x-artifact-client-interactive: int, x-artifact-tag: str, x-artifact-sha: str, x-artifact-dirty-hash: str, teamId: str, slug: str}
@returns(202) {urls: [str]}
@errors {400, 401, 402, 403}

@endpoint GET /v8/artifacts/{hash}
@required {hash: str}
@optional {x-artifact-client-ci: str, x-artifact-client-interactive: int, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404}

@endpoint HEAD /v8/artifacts/{hash}
@required {hash: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404}

@endpoint POST /v8/artifacts
@required {hashes: [str]}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403}

@endgroup

@group billing
@endpoint GET /v1/billing/charges
@required {from: str, to: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 500, 503}

@endpoint GET /v1/billing/contract-commitments
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/billing/buy
@required {item: map{type!: str, creditType!: str, amount!: int}}
@optional {source: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 500}

@endgroup

@group bulk-redirects
@endpoint PUT /v1/bulk-redirects
@required {projectId: str, teamId: str}
@optional {teamId: str, slug: str, overwrite: bool, name: str, redirects: [map{source!: str, destination!: str, statusCode: any, permanent: bool, caseSensitive: bool, query: bool, preserveQueryParams: bool}]=}
@returns(200) {alias: str?, version: map{id: str, key: str, lastModified: num, createdBy: str, name: str, isStaging: bool, isLive: bool, redirectCount: num, alias: str}}
@errors {400, 401, 403, 500}

@endpoint GET /v1/bulk-redirects
@required {projectId: str}
@optional {versionId: str, q: str, diff: any, page: int, per_page: int, sort_by: str(source/destination/statusCode), sort_order: str(asc/desc), teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/bulk-redirects
@required {projectId: str, redirects: [str]}
@optional {teamId: str, slug: str, name: str}
@returns(200)
@errors {400, 401, 403, 404, 500}

@endpoint PATCH /v1/bulk-redirects
@required {projectId: str, redirect: map{source!: str, destination: str, statusCode: num, permanent: bool, caseSensitive: bool, query: bool, preserveQueryParams: bool}}
@optional {teamId: str, slug: str, name: str, restore: bool}
@returns(200) {alias: str?, version: map{id: str, key: str, lastModified: num, createdBy: str, name: str, isStaging: bool, isLive: bool, redirectCount: num, alias: str}}
@errors {400, 401, 403, 404, 500}

@endpoint POST /v1/bulk-redirects/restore
@required {projectId: str, redirects: [str]}
@optional {teamId: str, slug: str, name: str}
@returns(200) {version: map{id: str, key: str, lastModified: num, createdBy: str, name: str, isStaging: bool, isLive: bool, redirectCount: num, alias: str}, restored: [str], failedToRestore: [str]}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v1/bulk-redirects/versions
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {versions: [map]}
@errors {400, 401, 403, 500}

@endpoint POST /v1/bulk-redirects/versions
@required {projectId: str, id: str, action: str(promote/restore/discard)}
@optional {teamId: str, slug: str, name: str}
@returns(200) {version: map{id: str, key: str, lastModified: num, createdBy: str, name: str, isStaging: bool, isLive: bool, redirectCount: num, alias: str}}
@errors {400, 401, 403, 404, 500}

@endgroup

@group projects
@endpoint GET /v2/projects/{projectIdOrName}/checks
@required {projectIdOrName: str}
@optional {blocks: str(build-start/deployment-start/deployment-alias/deployment-promotion/none), teamId: str, slug: str}
@returns(200) {checks: [map]}
@errors {400, 401, 403, 500}

@endpoint POST /v2/projects/{projectIdOrName}/checks
@required {projectIdOrName: str, name: str, requires: str(build-ready/deployment-url/none)=deployment-url}
@optional {teamId: str, slug: str, isRerequestable: bool, targets: [str], blocks: str(build-start/deployment-start/deployment-alias/deployment-promotion/none)=deployment-alias, source: map, timeout: num=300}
@returns(200) {id: str, name: str, ownerId: str, projectId: str, isRerequestable: bool, requires: str, source: any, blocks: str, targets: [str], sourceKind: str, sourceIntegrationConfigurationId: str, timeout: num, createdAt: num, updatedAt: num, deletedAt: num}
@errors {400, 401, 403, 500}

@endpoint GET /v2/projects/{projectIdOrName}/checks/{checkId}
@required {projectIdOrName: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, name: str, ownerId: str, projectId: str, isRerequestable: bool, requires: str, source: any, blocks: str, targets: [str], sourceKind: str, sourceIntegrationConfigurationId: str, timeout: num, createdAt: num, updatedAt: num, deletedAt: num}
@errors {400, 401, 403, 500}

@endpoint PATCH /v2/projects/{projectIdOrName}/checks/{checkId}
@required {projectIdOrName: str, checkId: str}
@optional {teamId: str, slug: str, name: str, isRerequestable: bool, requires: str(build-ready/deployment-url)=deployment-url, targets: [str], blocks: str(build-start/deployment-start/deployment-alias/deployment-promotion/none)=deployment-alias, timeout: num=300}
@returns(200) {id: str, name: str, ownerId: str, projectId: str, isRerequestable: bool, requires: str, source: any, blocks: str, targets: [str], sourceKind: str, sourceIntegrationConfigurationId: str, timeout: num, createdAt: num, updatedAt: num, deletedAt: num}
@errors {400, 401, 403, 404, 500}

@endpoint DELETE /v2/projects/{projectIdOrName}/checks/{checkId}
@required {projectIdOrName: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200) {success: bool}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v2/projects/{projectIdOrName}/checks/{checkId}/runs
@required {projectIdOrName: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200) {runs: [map]}
@errors {400, 401, 403, 500}

@endgroup

@group deployments
@endpoint GET /v2/deployments/{deploymentId}/check-runs
@required {deploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {runs: [map]}
@errors {400, 401, 403, 500}

@endpoint POST /v2/deployments/{deploymentId}/check-runs
@required {deploymentId: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, name: str, checkId: str, ownerId: str, deploymentId: str, projectId: str, source: any, requires: str, blocks: str, targets: [str], status: str, conclusion: str, conclusionText: str, externalId: str, externalUrl: str, output: map, timeout: num, createdAt: num, updatedAt: num, completedAt: num}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v2/deployments/{deploymentId}/check-runs/{checkRunId}
@required {deploymentId: str, checkRunId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, name: str, checkId: str, ownerId: str, deploymentId: str, projectId: str, source: any, requires: str, blocks: str, targets: [str], status: str, conclusion: str, conclusionText: str, externalId: str, externalUrl: str, output: map, timeout: num, createdAt: num, updatedAt: num, completedAt: num}
@errors {400, 401, 403, 404, 500}

@endpoint PATCH /v2/deployments/{deploymentId}/check-runs/{checkRunId}
@required {deploymentId: str, checkRunId: str}
@optional {teamId: str, slug: str, externalId: str, externalUrl: str(uri), status: str(queued/running/completed), output: map, completedAt: num, conclusion: str(canceled/skipped/timeout/failed/neutral/succeeded), conclusionText: str}
@returns(200) {id: str, name: str, checkId: str, ownerId: str, deploymentId: str, projectId: str, source: any, requires: str, blocks: str, targets: [str], status: str, conclusion: str, conclusionText: str, externalId: str, externalUrl: str, output: map, timeout: num, createdAt: num, updatedAt: num, completedAt: num}
@errors {400, 401, 403, 413, 500}

@endpoint POST /v1/deployments/{deploymentId}/checks
@required {deploymentId: str, name: str, blocking: bool}
@optional {teamId: str, slug: str, path: str, detailsUrl: str, externalId: str, rerequestable: bool}
@returns(200) {id: str, name: str, createdAt: num, updatedAt: num, deploymentId: str, status: str, conclusion: str, externalId: str, output: map{metrics: map{FCP: map{value: num?, previousValue: num, source: str}, LCP: map{value: num?, previousValue: num, source: str}, CLS: map{value: num?, previousValue: num, source: str}, TBT: map{value: num?, previousValue: num, source: str}, virtualExperienceScore: map{value: num?, previousValue: num, source: str}}}, completedAt: num, path: str, blocking: bool, detailsUrl: str, integrationId: str, startedAt: num, rerequestable: bool}
@errors {400, 401, 403, 404}

@endpoint GET /v1/deployments/{deploymentId}/checks
@required {deploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {checks: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /v1/deployments/{deploymentId}/checks/{checkId}
@required {deploymentId: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, name: str, createdAt: num, updatedAt: num, deploymentId: str, status: str, conclusion: str, externalId: str, output: map{metrics: map{FCP: map{value: num?, previousValue: num, source: str}, LCP: map{value: num?, previousValue: num, source: str}, CLS: map{value: num?, previousValue: num, source: str}, TBT: map{value: num?, previousValue: num, source: str}, virtualExperienceScore: map{value: num?, previousValue: num, source: str}}}, completedAt: num, path: str, blocking: bool, detailsUrl: str, integrationId: str, startedAt: num, rerequestable: bool}
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/deployments/{deploymentId}/checks/{checkId}
@required {deploymentId: str, checkId: str}
@optional {teamId: str, slug: str, name: str, path: str, status: any(running/completed), conclusion: any(canceled/failed/neutral/succeeded/skipped), detailsUrl: str, output: map{metrics: map}, externalId: str}
@returns(200) {id: str, name: str, createdAt: num, updatedAt: num, deploymentId: str, status: str, conclusion: str, externalId: str, output: map{metrics: map{FCP: map{value: num?, previousValue: num, source: str}, LCP: map{value: num?, previousValue: num, source: str}, CLS: map{value: num?, previousValue: num, source: str}, TBT: map{value: num?, previousValue: num, source: str}, virtualExperienceScore: map{value: num?, previousValue: num, source: str}}}, completedAt: num, path: str, blocking: bool, detailsUrl: str, integrationId: str, startedAt: num, rerequestable: bool}
@errors {400, 401, 403, 404, 413}

@endpoint POST /v1/deployments/{deploymentId}/checks/{checkId}/rerequest
@required {deploymentId: str, checkId: str}
@optional {autoUpdate: bool, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endgroup

@group connect
@endpoint GET /v1/connect/networks
@optional {includeHostedZones: bool=true, includePeeringConnections: bool=true, includeProjects: bool=true, search: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v1/connect/networks
@required {cidr: str, name: str, region: str}
@optional {teamId: str, slug: str, awsAvailabilityZoneIds: [str]}
@returns(201) {awsAccountId: str, awsAvailabilityZoneIds: [str], awsRegion: str, cidr: str, createdAt: num, egressIpAddresses: [str], hostedZones: map{count: num}, id: str, name: str, peeringConnections: map{count: num}, projects: map{count: num, ids: [str]}, region: str, status: str, teamId: str, vpcId: str}
@errors {400, 401, 402, 403, 409}

@endpoint DELETE /v1/connect/networks/{networkId}
@required {networkId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 402, 403, 409}

@endpoint PATCH /v1/connect/networks/{networkId}
@required {networkId: str, name: str}
@optional {teamId: str, slug: str}
@returns(200) {awsAccountId: str, awsAvailabilityZoneIds: [str], awsRegion: str, cidr: str, createdAt: num, egressIpAddresses: [str], hostedZones: map{count: num}, id: str, name: str, peeringConnections: map{count: num}, projects: map{count: num, ids: [str]}, region: str, status: str, teamId: str, vpcId: str}
@errors {400, 401, 403}

@endpoint GET /v1/connect/networks/{networkId}
@required {networkId: str}
@optional {teamId: str, slug: str}
@returns(200) {awsAccountId: str, awsAvailabilityZoneIds: [str], awsRegion: str, cidr: str, createdAt: num, egressIpAddresses: [str], hostedZones: map{count: num}, id: str, name: str, peeringConnections: map{count: num}, projects: map{count: num, ids: [str]}, region: str, status: str, teamId: str, vpcId: str}
@errors {400, 401, 403}

@endgroup

@group deployments
@endpoint GET /v3/deployments/{idOrUrl}/events
@required {idOrUrl: str}
@optional {direction: str(backward/forward)=forward, follow: num(0/1), limit: num, name: str, since: num, until: num, statusCode: any, delimiter: num(0/1), builds: num(0/1), teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 500}

@endpoint PATCH /v1/deployments/{deploymentId}/integrations/{integrationConfigurationId}/resources/{resourceId}/actions/{action}
@required {deploymentId: str, integrationConfigurationId: str, resourceId: str, action: str}
@optional {status: str(running/succeeded/failed), statusText: str, statusUrl: str(uri), outcomes: [any]}
@returns(202)
@errors {400, 401, 403}

@endpoint GET /v13/deployments/{idOrUrl}
@required {idOrUrl: str}
@optional {withGitRepoInfo: str, teamId: str, slug: str}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /v13/deployments
@required {name: str}
@optional {forceNew: any(0/1), skipAutoDetectionConfirmation: any(0/1), teamId: str, slug: str, customEnvironmentSlugOrId: str, deploymentId: str, files: [any], gitMetadata: map{remoteUrl: str, commitAuthorName: str, commitAuthorEmail: str, commitMessage: str, commitRef: str, commitSha: str, dirty: bool, ci: bool, ciType: str, ciGitProviderUsername: str, ciGitRepoVisibility: str}, gitSource: any, meta: map, monorepoManager: str, project: str, projectSettings: map{buildCommand: str, commandForIgnoringBuildStep: str, devCommand: str, framework: str, installCommand: str, nodeVersion: str, outputDirectory: str, rootDirectory: str, serverlessFunctionRegion: str, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool}, target: str, withLatestCommit: bool}
@returns(200) {aliasAssignedAt: any?, alwaysRefuseToBuild: bool, build: map{env: [str]}, buildArtifactUrls: [str], builds: [map], env: [str], inspectorUrl: str?, isInConcurrentBuildsQueue: bool, isInSystemBuildsQueue: bool, projectSettings: map{nodeVersion: str, buildCommand: str?, devCommand: str?, framework: str?, commandForIgnoringBuildStep: str?, installCommand: str?, outputDirectory: str?, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}}, integrations: map{status: str, startedAt: num, claimedAt: num, completedAt: num, skippedAt: num, skippedBy: str}, images: map{sizes: [num], qualities: [num], domains: [str], remotePatterns: [map], localPatterns: [map], minimumCacheTTL: num, formats: [str], dangerouslyAllowSVG: bool, contentSecurityPolicy: str, contentDispositionType: str}, alias: [str], aliasAssigned: bool, bootedAt: num, buildingAt: num, buildContainerFinishedAt: num, buildSkipped: bool, creator: map{uid: str, username: str, avatar: str}, initReadyAt: num, isFirstBranchDeployment: bool, lambdas: [map], public: bool, ready: num, status: str, team: map{id: str, name: str, slug: str, avatar: str}, userAliases: [str], previewCommentsEnabled: bool, ttyBuildLogs: bool, customEnvironment: any, oomReport: str, readyStateReason: str, aliasWarning: map?{code: str, message: str, link: str, action: str}, id: str, createdAt: num, readyState: str, name: str, type: str, aliasError: map?{code: str, message: str}, aliasFinal: str?, autoAssignCustomDomains: bool, automaticAliases: [str], buildErrorAt: num, checksState: str, checksConclusion: str, deletedAt: num?, defaultRoute: str, canceledAt: num, errorCode: str, errorLink: str, errorMessage: str?, errorStep: str, passiveRegions: [str], gitSource: any, manualProvisioning: map{state: str, completedAt: num}, meta: map, originCacheRegion: str, nodeVersion: str, project: map{id: str, name: str, framework: str?}, prebuilt: bool, readySubstate: str, regions: [str], softDeletedByRetention: bool, source: str, target: str?, undeletedAt: num, url: str, userConfiguredDeploymentId: str, version: num, oidcTokenClaims: map{iss: str, sub: str, scope: str, aud: str, owner: str, owner_id: str, project: str, project_id: str, environment: str, plan: str}, projectId: str, plan: str, platform: map{source: map{name: str}, origin: map{type: str, value: str}, creator: map{name: str, avatar: str}, meta: map}, connectBuildsEnabled: bool, connectConfigurationId: str, createdIn: str, crons: [map], functions: map?, monorepoManager: str?, ownerId: str, passiveConnectConfigurationId: str, routes: [any]?, gitRepo: any?, flags: any, microfrontends: any, config: map{version: num, functionType: str, functionMemoryType: str, functionTimeout: num?, secureComputePrimaryRegion: str?, secureComputeFallbackRegion: str?, isUsingActiveCPU: bool, resourceConfig: map{buildQueue: map{configuration: str}, elasticConcurrency: str, buildMachine: map{purchaseType: str?}}}, checks: map{deployment-alias: map{state: str, startedAt: num, completedAt: num}}, seatBlock: map{blockCode: str, userId: str, isVerified: bool, gitUserId: any, gitProvider: str}, attribution: map{commitMeta: map{email: str, name: str, isVerified: bool}, gitUser: map{id: any, login: str, type: str}, vercelUser: map{id: str, username: str, teamRoles: [str]}}}
@errors {400, 401, 402, 403, 404, 409, 426, 429, 500, 503}

@endpoint PATCH /v12/deployments/{id}/cancel
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {aliasAssignedAt: any?, alwaysRefuseToBuild: bool, build: map{env: [str]}, buildArtifactUrls: [str], builds: [map], env: [str], inspectorUrl: str?, isInConcurrentBuildsQueue: bool, isInSystemBuildsQueue: bool, projectSettings: map{nodeVersion: str, buildCommand: str?, devCommand: str?, framework: str?, commandForIgnoringBuildStep: str?, installCommand: str?, outputDirectory: str?, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}}, integrations: map{status: str, startedAt: num, claimedAt: num, completedAt: num, skippedAt: num, skippedBy: str}, images: map{sizes: [num], qualities: [num], domains: [str], remotePatterns: [map], localPatterns: [map], minimumCacheTTL: num, formats: [str], dangerouslyAllowSVG: bool, contentSecurityPolicy: str, contentDispositionType: str}, alias: [str], aliasAssigned: bool, bootedAt: num, buildingAt: num, buildContainerFinishedAt: num, buildSkipped: bool, creator: map{uid: str, username: str, avatar: str}, initReadyAt: num, isFirstBranchDeployment: bool, lambdas: [map], public: bool, ready: num, status: str, team: map{id: str, name: str, slug: str, avatar: str}, userAliases: [str], previewCommentsEnabled: bool, ttyBuildLogs: bool, customEnvironment: any, oomReport: str, readyStateReason: str, aliasWarning: map?{code: str, message: str, link: str, action: str}, id: str, createdAt: num, readyState: str, name: str, type: str, aliasError: map?{code: str, message: str}, aliasFinal: str?, autoAssignCustomDomains: bool, automaticAliases: [str], buildErrorAt: num, checksState: str, checksConclusion: str, deletedAt: num?, defaultRoute: str, canceledAt: num, errorCode: str, errorLink: str, errorMessage: str?, errorStep: str, passiveRegions: [str], gitSource: any, manualProvisioning: map{state: str, completedAt: num}, meta: map, originCacheRegion: str, nodeVersion: str, project: map{id: str, name: str, framework: str?}, prebuilt: bool, readySubstate: str, regions: [str], softDeletedByRetention: bool, source: str, target: str?, undeletedAt: num, url: str, userConfiguredDeploymentId: str, version: num, oidcTokenClaims: map{iss: str, sub: str, scope: str, aud: str, owner: str, owner_id: str, project: str, project_id: str, environment: str, plan: str}, projectId: str, plan: str, platform: map{source: map{name: str}, origin: map{type: str, value: str}, creator: map{name: str, avatar: str}, meta: map}, connectBuildsEnabled: bool, connectConfigurationId: str, createdIn: str, crons: [map], functions: map?, monorepoManager: str?, ownerId: str, passiveConnectConfigurationId: str, routes: [any]?, gitRepo: any?, flags: any, microfrontends: any, config: map{version: num, functionType: str, functionMemoryType: str, functionTimeout: num?, secureComputePrimaryRegion: str?, secureComputeFallbackRegion: str?, isUsingActiveCPU: bool, resourceConfig: map{buildQueue: map{configuration: str}, elasticConcurrency: str, buildMachine: map{purchaseType: str?}}}, checks: map{deployment-alias: map{state: str, startedAt: num, completedAt: num}}, seatBlock: map{blockCode: str, userId: str, isVerified: bool, gitUserId: any, gitProvider: str}, attribution: map{commitMeta: map{email: str, name: str, isVerified: bool}, gitUser: map{id: any, login: str, type: str}, vercelUser: map{id: str, username: str, teamRoles: [str]}}}
@errors {400, 401, 403, 404}

@endgroup

@group domains
@endpoint GET /v5/domains/{domain}/records
@required {domain: str}
@optional {limit: str, since: str, until: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v2/domains/{domain}/records
@required {domain: str, type: str(A/AAAA/ALIAS/CAA/CNAME/HTTPS/MX/SRV/TXT/NS)}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 409}

@endpoint PATCH /v1/domains/records/{recordId}
@required {recordId: str}
@optional {teamId: str, slug: str, name: str, value: str, type: str(A/AAAA/ALIAS/CAA/CNAME/HTTPS/MX/SRV/TXT/NS), ttl: int, mxPriority: int, srv: map{target!: str, weight!: int, port!: int, priority!: int}, https: map{priority!: int, target!: str, params: str}, comment: str}
@returns(200) {id: str, name: str, type: str, value: str, creator: str, domain: str, ttl: num, comment: str, recordType: str, createdAt: num?}
@errors {400, 401, 402, 403, 404, 409}

@endpoint DELETE /v2/domains/{domain}/records/{recordId}
@required {domain: str, recordId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endgroup

@group registrar
@endpoint GET /v1/registrar/tlds/supported
@optional {teamId: str}
@returns(200)
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/tlds/{tld}
@required {tld: str}
@optional {teamId: str}
@returns(200) {supportedLanguageCodes: map}
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/tlds/{tld}/price
@required {tld: str}
@optional {years: str, teamId: str}
@returns(200) {years: num, purchasePrice: any, renewalPrice: any, transferPrice: any}
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/domains/{domain}/availability
@required {domain: str}
@optional {teamId: str}
@returns(200) {available: bool}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /v1/registrar/domains/{domain}/price
@required {domain: str}
@optional {years: str, teamId: str}
@returns(200) {years: num, purchasePrice: any, renewalPrice: any, transferPrice: any}
@errors {400, 401, 403, 429, 500}

@endpoint POST /v1/registrar/domains/availability
@required {domains: [str]}
@optional {teamId: str}
@returns(200) {results: [map]}
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/domains/{domain}/auth-code
@required {domain: str}
@optional {teamId: str}
@returns(200) {authCode: str}
@errors {400, 401, 403, 404, 409, 429, 500}

@endpoint POST /v1/registrar/domains/{domain}/buy
@required {domain: str, autoRenew: bool, years: num, expectedPrice: num, contactInformation: map{firstName!: str, lastName!: str, email!: str, phone!: str, address1!: str, address2: str, city!: str, state!: str, zip!: str, country!: str, companyName: str, fax: str, additional: map}}
@optional {teamId: str, languageCode: str}
@returns(200) {orderId: str, _links: map}
@errors {400, 401, 403, 429, 500}

@endpoint POST /v1/registrar/domains/buy
@required {domains: [map{domainName!: str, autoRenew!: bool, years!: num, expectedPrice!: num, languageCode: str}], contactInformation: map{firstName!: str, lastName!: str, email!: str, phone!: str, address1!: str, address2: str, city!: str, state!: str, zip!: str, country!: str, companyName: str, fax: str, additional: map}}
@optional {teamId: str}
@returns(200) {orderId: str, _links: map}
@errors {400, 401, 403, 429, 500}

@endpoint POST /v1/registrar/domains/{domain}/transfer
@required {domain: str, authCode: str, autoRenew: bool, years: num, expectedPrice: num, contactInformation: map{firstName!: str, lastName!: str, email!: str, phone!: str, address1!: str, address2: str, city!: str, state!: str, zip!: str, country!: str, companyName: str, fax: str}}
@optional {teamId: str}
@returns(200) {orderId: str, _links: map}
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/domains/{domain}/transfer
@required {domain: str}
@optional {teamId: str}
@returns(200) {status: str}
@errors {400, 401, 403, 404, 429, 500}

@endpoint POST /v1/registrar/domains/{domain}/renew
@required {domain: str, years: num, expectedPrice: num}
@optional {teamId: str, contactInformation: map{firstName!: str, lastName!: str, email!: str, phone!: str, address1!: str, address2: str, city!: str, state!: str, zip!: str, country!: str, companyName: str, fax: str}}
@returns(200) {orderId: str, _links: map}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PATCH /v1/registrar/domains/{domain}/auto-renew
@required {domain: str, autoRenew: bool}
@optional {teamId: str}
@returns(204)
@errors {400, 401, 403, 404, 429, 500}

@endpoint PATCH /v1/registrar/domains/{domain}/nameservers
@required {domain: str, nameservers: [str]}
@optional {teamId: str}
@returns(204)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /v1/registrar/domains/{domain}/contact-info/schema
@required {domain: str}
@optional {teamId: str}
@returns(200)
@errors {400, 401, 403, 429, 500}

@endpoint GET /v1/registrar/orders/{orderId}
@required {orderId: str}
@optional {teamId: str}
@returns(200) {orderId: str, domains: [any], status: str, error: any}
@errors {400, 401, 403, 404, 429, 500}

@endgroup

@group domains
@endpoint GET /v6/domains/{domain}/config
@required {domain: str}
@optional {projectIdOrName: str, strict: any(true/false), teamId: str, slug: str}
@returns(200) {configuredBy: str?, acceptedChallenges: [str], recommendedIPv4: [map], recommendedCNAME: [map], misconfigured: bool}
@errors {400, 401, 403}

@endpoint GET /v5/domains/{domain}
@required {domain: str}
@optional {teamId: str, slug: str}
@returns(200) {domain: map{suffix: bool, verified: bool, nameservers: [str], intendedNameservers: [str], customNameservers: [str], creator: map{username: str, email: str, customerId: str?, isDomainReseller: bool, id: str}, name: str, teamId: str?, boughtAt: num?, createdAt: num, expiresAt: num?, id: str, renew: bool, serviceType: str, transferredAt: num?, transferStartedAt: num, userId: str}}
@errors {400, 401, 403, 404}

@endpoint GET /v5/domains
@optional {limit: num, since: num, until: num, teamId: str, slug: str}
@returns(200) {domains: [map], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 409}

@endpoint POST /v7/domains
@optional {teamId: str, slug: str, method: str}
@returns(200) {domain: map{verified: bool, nameservers: [str], intendedNameservers: [str], customNameservers: [str], creator: map{username: str, email: str, customerId: str?, isDomainReseller: bool, id: str}, name: str, teamId: str?, boughtAt: num?, createdAt: num, expiresAt: num?, id: str, renew: bool, serviceType: str, transferredAt: num?, transferStartedAt: num, userId: str}}
@errors {400, 401, 402, 403, 404, 409}

@endpoint PATCH /v3/domains/{domain}
@required {domain: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 409, 500}

@endpoint DELETE /v6/domains/{domain}
@required {domain: str}
@optional {teamId: str, slug: str}
@returns(200) {uid: str}
@errors {400, 401, 403, 404, 409}

@endgroup

@group log-drains
@endpoint GET /v1/log-drains/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {createdFrom: str, clientId: str, configurationId: str, projectsMetadata: [map]?, integrationIcon: str, integrationConfigurationUri: str, integrationWebsite: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/log-drains/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /v1/log-drains
@optional {projectId: str, projectIdOrName: str, includeMetadata: bool=false, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/log-drains
@required {deliveryFormat: any(json/ndjson), url: str(uri), sources: [str]}
@optional {teamId: str, slug: str, headers: map, projectIds: [str], environments: [str], secret: str, samplingRate: num, name: str}
@returns(200)
@errors {400, 401, 403}

@endgroup

@group drains
@endpoint POST /v1/drains
@required {name: str, projects: str(some/all), schemas: map}
@optional {teamId: str, slug: str, projectIds: [str], filter: any, delivery: map, sampling: [map{type!: str, rate!: num, env: str, requestPath: str}], transforms: [map{id!: str}], source: map}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/drains
@optional {projectId: str, includeMetadata: bool=false, teamId: str, slug: str}
@returns(200) {drains: any}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/drains/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /v1/drains/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/drains/{id}
@required {id: str}
@optional {teamId: str, slug: str, name: str, projects: str(some/all), projectIds: [str], filter: any, schemas: map, delivery: map, sampling: [map{type!: str, rate!: num, env: str, requestPath: str}], transforms: [map{id!: str}], status: str(enabled/disabled), source: map}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/drains/test
@required {schemas: map, delivery: map}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endgroup

@group edge-cache
@endpoint POST /v1/edge-cache/invalidate-by-tags
@required {projectIdOrName: str, tags: any}
@optional {teamId: str, slug: str, target: str(production/preview)}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/edge-cache/dangerously-delete-by-tags
@required {projectIdOrName: str, tags: any}
@optional {teamId: str, slug: str, revalidationDeadlineSeconds: num, target: str(production/preview)}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/edge-cache/invalidate-by-src-images
@required {projectIdOrName: str, srcImages: [str]}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404}

@endpoint POST /v1/edge-cache/dangerously-delete-by-src-images
@required {projectIdOrName: str, srcImages: [str]}
@optional {teamId: str, slug: str, revalidationDeadlineSeconds: num}
@returns(200)
@errors {400, 401, 402, 403, 404}

@endgroup

@group edge-config
@endpoint GET /v1/edge-config
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v1/edge-config
@required {slug: str}
@optional {teamId: str, slug: str, items: map}
@returns(201) {transfer: map{fromAccountId: str, startedAt: num, doneAt: num?}, id: str, createdAt: num, createdBy: str, ownerId: str, slug: str, updatedAt: num, digest: str, purpose: any, deletedAt: num?, schema: map, syncedToDynamoAt: num, sizeInBytes: num, itemCount: num}
@errors {400, 401, 402, 403}

@endpoint GET /v1/edge-config/{edgeConfigId}
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(200) {transfer: map{fromAccountId: str, startedAt: num, doneAt: num?}, id: str, createdAt: num, createdBy: str, ownerId: str, slug: str, updatedAt: num, digest: str, purpose: any, deletedAt: num?, schema: map, syncedToDynamoAt: num, sizeInBytes: num, itemCount: num}
@errors {400, 401, 403, 404}

@endpoint PUT /v1/edge-config/{edgeConfigId}
@required {edgeConfigId: str, slug: str}
@optional {teamId: str, slug: str}
@returns(200) {transfer: map{fromAccountId: str, startedAt: num, doneAt: num?}, id: str, createdAt: num, createdBy: str, ownerId: str, slug: str, updatedAt: num, digest: str, purpose: any, deletedAt: num?, schema: map, syncedToDynamoAt: num, sizeInBytes: num, itemCount: num}
@errors {400, 401, 402, 403, 404, 409}

@endpoint DELETE /v1/edge-config/{edgeConfigId}
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint GET /v1/edge-config/{edgeConfigId}/items
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/edge-config/{edgeConfigId}/items
@required {edgeConfigId: str, items: [any]}
@optional {teamId: str, slug: str}
@returns(200) {status: str}
@errors {400, 401, 402, 403, 404, 409, 412}

@endpoint GET /v1/edge-config/{edgeConfigId}/schema
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/edge-config/{edgeConfigId}/schema
@required {edgeConfigId: str, definition: any}
@optional {dryRun: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 409}

@endpoint DELETE /v1/edge-config/{edgeConfigId}/schema
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 409}

@endpoint GET /v1/edge-config/{edgeConfigId}/item/{edgeConfigItemKey}
@required {edgeConfigId: str, edgeConfigItemKey: str}
@optional {teamId: str, slug: str}
@returns(200) {key: str, value: any?, description: str, edgeConfigId: str, createdAt: num, updatedAt: num}
@errors {400, 401, 403, 404}

@endpoint GET /v1/edge-config/{edgeConfigId}/tokens
@required {edgeConfigId: str}
@optional {teamId: str, slug: str}
@returns(200) {token: str, label: str, id: str, edgeConfigId: str, createdAt: num}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/edge-config/{edgeConfigId}/tokens
@required {edgeConfigId: str, tokens: [str]}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 409}

@endpoint GET /v1/edge-config/{edgeConfigId}/token/{token}
@required {edgeConfigId: str, token: str}
@optional {teamId: str, slug: str}
@returns(200) {token: str, label: str, id: str, edgeConfigId: str, createdAt: num}
@errors {400, 401, 403, 404}

@endpoint POST /v1/edge-config/{edgeConfigId}/token
@required {edgeConfigId: str, label: str}
@optional {teamId: str, slug: str}
@returns(201) {token: str, id: str}
@errors {400, 401, 402, 403, 404, 409}

@endpoint GET /v1/edge-config/{edgeConfigId}/backups/{edgeConfigBackupVersionId}
@required {edgeConfigId: str, edgeConfigBackupVersionId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v1/edge-config/{edgeConfigId}/backups
@required {edgeConfigId: str}
@optional {next: str, limit: num, metadata: str, teamId: str, slug: str}
@returns(200) {backups: [map], pagination: map{hasNext: bool, next: str}}
@errors {400, 401, 403, 404}

@endgroup

@group env
@endpoint POST /v1/env
@required {evs: [map{key!: str, value!: str, comment: str}]}
@optional {teamId: str, slug: str, type: str(encrypted/sensitive), target: [any], projectId: [str]}
@returns(201) {created: [map], failed: [map]}
@errors {400, 401, 402, 403}

@endpoint GET /v1/env
@optional {search: str, projectId: str, ids: str, exclude_ids: str, exclude-ids: str, exclude_projectId: str, exclude-projectId: str, teamId: str, slug: str}
@returns(200) {data: [map], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/env
@required {updates: map}
@optional {teamId: str, slug: str}
@returns(200) {updated: [map], failed: [map]}
@errors {400, 401, 402, 403}

@endpoint DELETE /v1/env
@required {ids: [str]}
@optional {teamId: str, slug: str}
@returns(200) {deleted: [str], failed: [map]}
@errors {400, 401, 402, 403}

@endpoint GET /v1/env/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {created: str(date-time), key: str, ownerId: str?, id: str, createdBy: str?, deletedBy: str?, updatedBy: str?, createdAt: num, deletedAt: num, updatedAt: num, value: str, projectId: [str], type: str, target: [str], applyToAllCustomEnvironments: bool, decrypted: bool, comment: str, lastEditedByDisplayName: str}
@errors {400, 401, 403}

@endpoint PATCH /v1/env/{id}/unlink/{projectId}
@required {id: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str}
@errors {400, 401, 403}

@endgroup

@group events
@endpoint GET /v3/events
@optional {limit: num, since: str, until: str, types: str, userId: str, principalId: str, projectIds: str, withPayload: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/events/types
@optional {teamId: str, slug: str}
@returns(200) {types: [map]}
@errors {400, 401, 403}

@endgroup

@group projects
@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/flags
@required {projectIdOrName: str}
@optional {state: str(active/archived), withMetadata: bool, limit: int, cursor: str, search: str, teamId: str, slug: str}
@returns(200) {data: [map], pagination: map{next: str?}}
@errors {400, 401, 402, 403, 404}

@endpoint PUT /v1/projects/{projectIdOrName}/feature-flags/flags
@required {projectIdOrName: str, slug: str, kind: any(boolean/string/number/json), environments: map}
@optional {teamId: str, slug: str, variants: [map{id!: str, label: str, description: str, value!: any}], seed: num, description: str, state: str(active/archived)}
@returns(201) {description: str, experiment: map{name: str, id: str, numVariants: num, surfaceArea: str, stickyRequirement: bool, layer: str, guardrailMetrics: [map], hypothesis: str, device: str, controlVariantId: str, startedAt: num, endedAt: num, allocationUnit: str, primaryMetrics: [map], status: str}, variants: [map], id: str, environments: map, kind: str, revision: num, seed: num, state: str, slug: str, createdAt: num, updatedAt: num, createdBy: str, ownerId: str, projectId: str, typeName: str}
@errors {400, 401, 402, 403, 404, 409, 412}

@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/flags/{flagIdOrSlug}
@required {projectIdOrName: str, flagIdOrSlug: str}
@optional {ifMatch: str, withMetadata: bool, teamId: str, slug: str}
@returns(200) {description: str, experiment: map{name: str, id: str, numVariants: num, surfaceArea: str, stickyRequirement: bool, layer: str, guardrailMetrics: [map], hypothesis: str, device: str, controlVariantId: str, startedAt: num, endedAt: num, allocationUnit: str, primaryMetrics: [map], status: str}, variants: [map], id: str, environments: map, kind: str, revision: num, seed: num, state: str, slug: str, createdAt: num, updatedAt: num, createdBy: str, ownerId: str, projectId: str, typeName: str, metadata: map{creator: map{id: str, name: str}}}
@errors {304, 400, 401, 402, 403, 404}

@endpoint PATCH /v1/projects/{projectIdOrName}/feature-flags/flags/{flagIdOrSlug}
@required {projectIdOrName: str, flagIdOrSlug: str}
@optional {ifMatch: str, withMetadata: bool, teamId: str, slug: str, createdBy: str, message: str, variants: [map{id!: str, label: str, description: str, value!: any}], environments: map, seed: num, description: str, state: str(active/archived)}
@returns(200)
@errors {304, 400, 401, 402, 403, 404, 409, 412}

@endpoint DELETE /v1/projects/{projectIdOrName}/feature-flags/flags/{flagIdOrSlug}
@required {projectIdOrName: str, flagIdOrSlug: str}
@optional {ifMatch: str, withMetadata: bool, teamId: str, slug: str}
@returns(204)
@errors {304, 400, 401, 402, 403, 404, 409, 412}

@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/flags/{flagIdOrSlug}/versions
@required {projectIdOrName: str, flagIdOrSlug: str}
@optional {limit: num=20, cursor: str, environment: str, withMetadata: bool=false, teamId: str, slug: str}
@returns(200) {versions: [map], pagination: map}
@errors {304, 400, 401, 402, 403, 404}

@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/settings
@required {projectIdOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {typeName: str, projectId: str, ownerId: str, enabled: bool, environments: [str], connections: [map], entities: [map], createdAt: num, updatedAt: num, metadata: map{activeFlagCount: num, archivedFlagCount: num, segmentCount: num, packSizeInBytes: num, packRevision: num, configUpdatedAt: num}}
@errors {400, 401, 402, 403, 404}

@endpoint PATCH /v1/projects/{projectIdOrName}/feature-flags/settings
@required {projectIdOrName: str}
@optional {teamId: str, slug: str, enabled: bool, entities: [map{kind!: str, label!: str, attributes!: [map]}], environments: [str]}
@returns(200) {typeName: str, projectId: str, ownerId: str, enabled: bool, environments: [str], connections: [map], entities: [map], createdAt: num, updatedAt: num, metadata: map{activeFlagCount: num, archivedFlagCount: num, segmentCount: num, packSizeInBytes: num, packRevision: num, configUpdatedAt: num}}
@returns(201) {typeName: str, projectId: str, ownerId: str, enabled: bool, environments: [str], connections: [map], entities: [map], createdAt: num, updatedAt: num, metadata: map{activeFlagCount: num, archivedFlagCount: num, segmentCount: num, packSizeInBytes: num, packRevision: num, configUpdatedAt: num}}
@errors {400, 401, 402, 403, 404, 409, 412}

@endgroup

@group teams
@endpoint GET /v1/teams/{teamId}/feature-flags/settings
@required {teamId: str}
@optional {limit: int=20, cursor: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/teams/{teamId}/feature-flags/flags
@required {teamId: str}
@optional {state: str(active/archived), withMetadata: bool, limit: int=20, cursor: str, search: str, kind: str(boolean/string/number/json), slug: str}
@returns(200) {data: [map], pagination: map{next: str?}}
@errors {400, 401, 403}

@endgroup

@group projects
@endpoint PUT /v1/projects/{projectIdOrName}/feature-flags/segments
@required {projectIdOrName: str, slug: str, label: str, data: map{rules: [map], include: map, exclude: map}, hint: str}
@optional {teamId: str, slug: str, createdBy: str, description: str}
@returns(201) {description: str, createdBy: str, usedByFlags: [str], usedBySegments: [str], id: str, label: str, slug: str, createdAt: num, updatedAt: num, projectId: str, typeName: str, data: map{rules: [map], include: map, exclude: map}, hint: str}
@errors {400, 401, 402, 403, 404, 409, 412}

@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/segments
@required {projectIdOrName: str}
@optional {withMetadata: bool=false, teamId: str, slug: str}
@returns(200) {data: [map]}
@errors {400, 401, 402, 403, 404}

@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/segments/{segmentIdOrSlug}
@required {projectIdOrName: str, segmentIdOrSlug: str}
@optional {withMetadata: bool=false, teamId: str, slug: str}
@returns(200) {description: str, createdBy: str, usedByFlags: [str], usedBySegments: [str], id: str, label: str, slug: str, createdAt: num, updatedAt: num, projectId: str, typeName: str, data: map{rules: [map], include: map, exclude: map}, hint: str, metadata: map{creator: map{id: str, name: str}}}
@errors {400, 401, 402, 403, 404}

@endpoint DELETE /v1/projects/{projectIdOrName}/feature-flags/segments/{segmentIdOrSlug}
@required {projectIdOrName: str, segmentIdOrSlug: str}
@optional {withMetadata: bool=false, teamId: str, slug: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 409, 412}

@endpoint PATCH /v1/projects/{projectIdOrName}/feature-flags/segments/{segmentIdOrSlug}
@required {projectIdOrName: str, segmentIdOrSlug: str}
@optional {withMetadata: bool=false, teamId: str, slug: str, operations: [map{action!: str, field!: str, entity!: str, attribute!: str, value!: map}], label: str, description: str, data: map{rules: [map], include: map, exclude: map}, hint: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 409, 412}

@endgroup

@group deployments
@endpoint GET /v1/deployments/{deploymentId}/feature-flags
@required {deploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {flags: [map], status: map?{deploymentId: str, projectId: str, responseStatus: num, flagCount: num, createdAt: num}}
@errors {400, 401, 403, 404}

@endgroup

@group projects
@endpoint GET /v1/projects/{projectIdOrName}/feature-flags/sdk-keys
@required {projectIdOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {data: [map]}
@errors {400, 401, 402, 403, 404}

@endpoint PUT /v1/projects/{projectIdOrName}/feature-flags/sdk-keys
@required {projectIdOrName: str, sdkKeyType: str(server/mobile/client), environment: str}
@optional {teamId: str, slug: str, label: str}
@returns(200) {hashKey: str, projectId: str, type: str, environment: str, createdBy: str, createdAt: num, updatedAt: num, label: str, deletedAt: num, keyValue: str, tokenValue: str, connectionString: str}
@errors {400, 401, 402, 403, 404, 409}

@endpoint DELETE /v1/projects/{projectIdOrName}/feature-flags/sdk-keys/{hashKey}
@required {projectIdOrName: str, hashKey: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 409}

@endgroup

@group integrations
@endpoint GET /v1/integrations/git-namespaces
@optional {host: str, provider: any(github/github-limited/github-custom-host/gitlab/bitbucket)}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /v1/integrations/search-repo
@optional {query: str, namespaceId: any, provider: any(github/github-limited/github-custom-host/gitlab/bitbucket), installationId: str, host: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /v1/integrations/integration/{integrationIdOrSlug}/products/{productIdOrSlug}/plans
@required {integrationIdOrSlug: str, productIdOrSlug: str}
@optional {integrationConfigurationId: str, metadata: str, source: str(marketplace/deploy-button/external/v0/resource-claims/cli/oauth/backoffice), teamId: str, slug: str}
@returns(200) {plans: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /v1/integrations/installations/{integrationConfigurationId}/resources/{resourceId}/connections
@required {integrationConfigurationId: str, resourceId: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(201)
@errors {400, 401, 403, 404}

@endgroup

@group installations
@endpoint PATCH /v1/installations/{integrationConfigurationId}
@required {integrationConfigurationId: str}
@optional {status: str(ready/pending/onboarding/suspended/resumed/uninstalled/error), externalId: str, billingPlan: map{id!: str, type!: str, name!: str, description: str, paymentMethodRequired: bool, cost: str, details: [map], highlightedDetails: [map], effectiveDate: str}, notification: any}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/account
@required {integrationConfigurationId: str}
@returns(200) {name: str, url: str, contact: map?{email: str, name: str}}
@errors {400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/member/{memberId}
@required {integrationConfigurationId: str, memberId: str}
@returns(200) {id: str, role: str, globalUserId: str, userEmail: str}
@errors {400, 401, 403, 404}

@endpoint POST /v1/installations/{integrationConfigurationId}/events
@required {integrationConfigurationId: str, event: any}
@returns(201)
@errors {400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/resources
@required {integrationConfigurationId: str}
@returns(200) {resources: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/resources/{resourceId}
@required {integrationConfigurationId: str, resourceId: str}
@returns(200) {id: str, internalId: str, name: str, status: str, productId: str, protocolSettings: map{experimentation: map{edgeConfigSyncingEnabled: bool, edgeConfigId: str, edgeConfigTokenId: str}}, notification: map{title: str, level: str, message: str, href: str}, billingPlanId: str, metadata: map}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/installations/{integrationConfigurationId}/resources/{resourceId}
@required {integrationConfigurationId: str, resourceId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}
@required {integrationConfigurationId: str, resourceId: str, productId: str, name: str, status: str(ready/pending/onboarding/suspended/resumed/uninstalled/error)}
@optional {ownership: str(owned/linked/sandbox), metadata: map, billingPlan: map{id!: str, type!: str, name!: str, description: str, paymentMethodRequired: bool, cost: str, details: [map], highlightedDetails: [map], effectiveDate: str}, notification: map{level!: str, title!: str, message: str, href: str(uri)}, extras: map, secrets: [map{name!: str, value!: str, prefix: str, environmentOverrides: map}]}
@returns(200) {name: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /v1/installations/{integrationConfigurationId}/resources/{resourceId}
@required {integrationConfigurationId: str, resourceId: str}
@optional {ownership: str(owned/linked/sandbox), name: str, status: str(ready/pending/onboarding/suspended/resumed/uninstalled/error), metadata: map, billingPlan: map{id!: str, type!: str, name!: str, description: str, paymentMethodRequired: bool, cost: str, details: [map], highlightedDetails: [map], effectiveDate: str}, notification: any, extras: map, secrets: any}
@returns(200) {name: str}
@errors {400, 401, 403, 404, 409, 422}

@endpoint POST /v1/installations/{integrationConfigurationId}/billing
@required {integrationConfigurationId: str, timestamp: str(date-time), eod: str(date-time), period: map{start!: str(date-time), end!: str(date-time)}, billing: any, usage: [map{resourceId: str, name!: str, type!: str, units!: str, dayValue!: num, periodValue!: num, planValue: num}]}
@returns(201)
@errors {400, 401, 403, 404}

@endpoint POST /v1/installations/{integrationConfigurationId}/billing/invoices
@required {integrationConfigurationId: str, invoiceDate: str(date-time), period: map{start!: str(date-time), end!: str(date-time)}, items: [map{resourceId: str, billingPlanId!: str, start: str(date-time), end: str(date-time), name!: str, details: str, price!: str, quantity!: num, units!: str, total!: str}]}
@optional {externalId: str, memo: str, discounts: [map{resourceId: str, billingPlanId!: str, start: str(date-time), end: str(date-time), name!: str, details: str, amount!: str}], final: bool, test: map{validate: bool, result: str}}
@returns(200) {invoiceId: str, test: bool, validationErrors: [str]}
@errors {400, 401, 403, 404, 409}

@endpoint POST /v1/installations/{integrationConfigurationId}/billing/finalize
@required {integrationConfigurationId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/billing/invoices/{invoiceId}
@required {integrationConfigurationId: str, invoiceId: str}
@returns(200) {test: bool, invoiceId: str, externalId: str, state: str, invoiceNumber: str, invoiceDate: str, period: map{start: str, end: str}, paidAt: str, refundedAt: str, memo: str, items: [map], discounts: [map], total: str, refundReason: str, refundTotal: str, created: str, updated: str}
@errors {400, 401, 403, 404}

@endpoint POST /v1/installations/{integrationConfigurationId}/billing/invoices/{invoiceId}/actions
@required {integrationConfigurationId: str, invoiceId: str}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint POST /v1/installations/{integrationConfigurationId}/billing/balance
@required {integrationConfigurationId: str, timestamp: str(date-time), balances: [map{resourceId: str, credit: str, nameLabel: str, currencyValueInCents!: num}]}
@returns(201)
@errors {400, 401, 403, 404}

@endpoint PUT /v1/installations/{integrationConfigurationId}/products/{integrationProductIdOrSlug}/resources/{resourceId}/secrets
@required {integrationConfigurationId: str, integrationProductIdOrSlug: str, resourceId: str, secrets: [map{name!: str, value!: str, prefix: str, environmentOverrides: map}]}
@optional {partial: bool}
@returns(201)
@errors {400, 401, 403, 404, 409, 422}

@endpoint PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}/secrets
@required {integrationConfigurationId: str, resourceId: str, secrets: [map{name!: str, value!: str, prefix: str, environmentOverrides: map}]}
@optional {partial: bool}
@returns(201)
@errors {400, 401, 403, 404, 409, 422}

@endgroup

@group integrations
@endpoint GET /v1/integrations/configurations
@required {view: str(account/project)}
@optional {installationType: str(marketplace/external/provisioning), integrationIdOrSlug: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/integrations/configuration/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/integrations/configuration/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /v1/integrations/configuration/{id}/products
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {products: [map], integration: map{id: str, slug: str, name: str}, configuration: map{id: str}}
@errors {400, 401, 403, 404, 500}

@endpoint POST /v1/integrations/sso/token
@returns(200)
@errors {400, 403, 500}

@endpoint GET /v2/integrations/log-drains
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v2/integrations/log-drains
@required {name: str, url: str(uri)}
@optional {teamId: str, slug: str, projectIds: [str], secret: str, deliveryFormat: any(json/ndjson), sources: [str], headers: map, environments: [str]}
@returns(200) {clientId: str, configurationId: str, createdAt: num, id: str, deliveryFormat: str, name: str, ownerId: str, projectId: str?, projectIds: [str], url: str, sources: [str], createdFrom: str, headers: map, environments: [str], branch: str, samplingRate: num, source: any}
@errors {400, 401, 403}

@endpoint DELETE /v1/integrations/log-drains/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404}

@endgroup

@group projects
@endpoint GET /v1/projects/{projectId}/deployments/{deploymentId}/runtime-logs
@required {projectId: str, deploymentId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endgroup

@group installations
@endpoint POST /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items
@required {integrationConfigurationId: str, resourceId: str, items: [map{id!: str, slug!: str, origin!: str, category: str, name: str, description: str, isArchived: bool, createdAt: num, updatedAt: num}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items/{itemId}
@required {integrationConfigurationId: str, resourceId: str, itemId: str, slug: str, origin: str}
@optional {name: str, category: str(experiment/flag), description: str, isArchived: bool, createdAt: num, updatedAt: num}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items/{itemId}
@required {integrationConfigurationId: str, resourceId: str, itemId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint HEAD /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/edge-config
@required {integrationConfigurationId: str, resourceId: str}
@returns(200) {items: map, updatedAt: num, digest: str, purpose: str}
@errors {304, 400, 401, 403, 404}

@endpoint GET /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/edge-config
@required {integrationConfigurationId: str, resourceId: str}
@returns(200) {items: map, updatedAt: num, digest: str, purpose: str}
@errors {304, 400, 401, 403, 404}

@endpoint PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/edge-config
@required {integrationConfigurationId: str, resourceId: str, data: map}
@returns(200) {items: map, updatedAt: num, digest: str, purpose: str}
@errors {400, 401, 403, 404, 409, 412}

@endgroup

@group microfrontends
@endpoint GET /v1/microfrontends/groups
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 500}

@endpoint GET /v1/microfrontends/groups/{groupId}/projects
@required {groupId: str}
@optional {teamId: str, slug: str}
@returns(200) {projects: [map]}
@errors {400, 401, 403}

@endpoint GET /v1/microfrontends/{deploymentId}/config
@required {deploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {config: map?{$schema: str, version: str, applications: map, options: map{disableOverrides: bool, localProxyPort: num}}}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v1/microfrontends/projects/{projectIdOrName}/production-mfe-config
@required {projectIdOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {config: map?{$schema: str, version: str, applications: map, options: map{disableOverrides: bool, localProxyPort: num}}}
@errors {400, 401, 403, 404, 500}

@endpoint POST /v1/microfrontends/group
@required {groupName: str, defaultApp: map{projectId!: str, defaultRoute: str}, otherApplications: [map{projectId!: str, defaultRoute: str}]}
@optional {teamId: str, slug: str}
@returns(200) {newMicrofrontendsGroup: map{id: str, slug: str, name: str, fallbackEnvironment: str, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 500}

@endgroup

@group observability
@endpoint GET /v1/observability/manage/configuration/projects
@optional {teamId: str, slug: str}
@returns(200) {disabledProjects: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /v1/observability/manage/configuration/projects/{projectIdOrName}
@required {projectIdOrName: str, disabled: bool}
@optional {teamId: str, slug: str}
@returns(200) {id: str, disabledAt: num}
@errors {400, 401, 403, 404}

@endgroup

@group projects
@endpoint GET /v1/projects/{idOrName}/members
@required {idOrName: str}
@optional {limit: int, since: int, until: int, search: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v1/projects/{idOrName}/members
@required {idOrName: str, role: str(ADMIN/PROJECT_VIEWER/PROJECT_DEVELOPER)}
@optional {teamId: str, slug: str, uid: str, username: str, email: str(email)}
@returns(200) {id: str}
@errors {400, 401, 403, 500}

@endpoint DELETE /v1/projects/{idOrName}/members/{uid}
@required {idOrName: str, uid: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str}
@errors {400, 401, 403}

@endpoint GET /v1/projects/{projectId}/routes
@required {projectId: str}
@optional {versionId: str, q: str, filter: str(rewrite/redirect/set_status/transform), diff: any, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /v1/projects/{projectId}/routes
@required {projectId: str}
@optional {teamId: str, slug: str, overwrite: bool, routes: [map{id!: str, name!: str, description: str, enabled: bool, route!: map}]=}
@returns(200) {version: map{id: str, s3Key: str, lastModified: num, createdBy: str, isStaging: bool, isLive: bool, ruleCount: num, alias: str}}
@errors {400, 401, 403}

@endpoint POST /v1/projects/{projectId}/routes
@required {projectId: str, route: map{name!: str, description: str, enabled: bool, srcSyntax: str, route!: map}}
@optional {teamId: str, slug: str, position: map{placement: str, referenceId: str}}
@returns(200) {route: map{routeType: str, id: str, name: str, description: str, enabled: bool, staged: bool, route: map{src: str, dest: str, headers: map, methods: [str], continue: bool, override: bool, caseSensitive: bool, check: bool, important: bool, status: num, has: [any], missing: [any], mitigate: map{action: str}, transforms: [map], env: [str], locale: map{redirect: map, cookie: str}, source: str, destination: str, statusCode: num, middlewarePath: str, middlewareRawSrc: [str], middleware: num, respectOriginCacheControl: bool}, rawSrc: str, rawDest: str, srcSyntax: str}, version: map{id: str, s3Key: str, lastModified: num, createdBy: str, isStaging: bool, isLive: bool, ruleCount: num, alias: str}}
@errors {400, 401, 403}

@endpoint DELETE /v1/projects/{projectId}/routes
@required {projectId: str, routeIds: [str]}
@optional {teamId: str, slug: str}
@returns(200) {deletedCount: num, version: map{id: str, s3Key: str, lastModified: num, createdBy: str, isStaging: bool, isLive: bool, ruleCount: num, alias: str}}
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/projects/{projectId}/routes/{routeId}
@required {projectId: str, routeId: str}
@optional {teamId: str, slug: str, route: map{name!: str, description: str, enabled: bool, srcSyntax: str, route!: map}, restore: bool}
@returns(200) {route: map{routeType: str, id: str, name: str, description: str, enabled: bool, staged: bool, route: map{src: str, dest: str, headers: map, methods: [str], continue: bool, override: bool, caseSensitive: bool, check: bool, important: bool, status: num, has: [any], missing: [any], mitigate: map{action: str}, transforms: [map], env: [str], locale: map{redirect: map, cookie: str}, source: str, destination: str, statusCode: num, middlewarePath: str, middlewareRawSrc: [str], middleware: num, respectOriginCacheControl: bool}, rawSrc: str, rawDest: str, srcSyntax: str}, version: map{id: str, s3Key: str, lastModified: num, createdBy: str, isStaging: bool, isLive: bool, ruleCount: num, alias: str}}
@errors {400, 401, 403, 404}

@endpoint POST /v1/projects/{projectId}/routes/generate
@required {projectId: str, prompt: str}
@optional {teamId: str, slug: str, currentRoute: map{name: str, description: str, pathCondition!: map, conditions: [map], actions!: [map]}}
@returns(200) {route: map{name: str, description: str, pathCondition: map{value: str, syntax: str}, conditions: [map], actions: [map]}, error: str}
@errors {400, 401, 403, 408, 500}

@endpoint GET /v1/projects/{projectId}/routes/versions
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {versions: [map]}
@errors {400, 401, 403}

@endpoint POST /v1/projects/{projectId}/routes/versions
@required {projectId: str, id: str, action: str(promote/restore/discard)}
@optional {teamId: str, slug: str}
@returns(200) {version: map{id: str, s3Key: str, lastModified: num, createdBy: str, isStaging: bool, isLive: bool, ruleCount: num, alias: str}}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v10/projects
@optional {from: str, gitForkProtection: str(1/0), limit: str, search: str, repo: str, repoId: str, repoUrl: str, excludeRepos: str, edgeConfigId: str, edgeConfigTokenId: str, deprecated: bool, elasticConcurrencyEnabled: str(1/0), staticIpsEnabled: str(0/1), buildMachineTypes: str, buildQueueConfiguration: str(SKIP_NAMESPACE_QUEUE/WAIT_FOR_NAMESPACE_QUEUE), teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v11/projects
@required {name: str}
@optional {teamId: str, slug: str, enablePreviewFeedback: bool, enableProductionFeedback: bool, previewDeploymentsDisabled: bool, previewDeploymentSuffix: str, buildCommand: str, commandForIgnoringBuildStep: str, devCommand: str, environmentVariables: [map{key!: str, target!: any, gitBranch: str, type: str, value!: str}], framework: any(services/blitzjs/nextjs/gatsby/remix/react-router/astro/hexo/eleventy/docusaurus-2/docusaurus/preact/solidstart-1/solidstart/dojo/ember/vue/scully/ionic-angular/angular/polymer/svelte/sveltekit/sveltekit-1/ionic-react/create-react-app/gridsome/umijs/sapper/saber/stencil/nuxtjs/redwoodjs/hugo/jekyll/brunch/middleman/zola/hydrogen/vite/tanstack-start/vitepress/vuepress/parcel/fastapi/flask/fasthtml/django/sanity-v3/sanity/storybook/nitro/hono/express/h3/koa/nestjs/elysia/fastify/xmcp/python/ruby/rust/node/go), gitRepository: map{repo!: str, type!: any}, installCommand: str, skipGitConnectDuringLink: bool, ssoProtection: map{deploymentType!: str}, outputDirectory: str, publicSource: bool, rootDirectory: str, serverlessFunctionRegion: str, serverlessFunctionZeroConfigFailover: any, oidcTokenConfig: map{enabled: bool, issuerMode: str}, enableAffectedProjectsDeployments: bool, resourceConfig: map{fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: any, functionZeroConfigFailover: any, elasticConcurrencyEnabled: bool, buildMachineType: any, buildMachineSelection: any, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map}}
@returns(200) {accountId: str, analytics: map{id: str, canceledAt: num?, disabledAt: num, enabledAt: num, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, autoExposeSystemEnvs: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, buildCommand: str?, commandForIgnoringBuildStep: str?, connectConfigurations: [map]?, connectConfigurationId: str?, connectBuildsEnabled: bool, passiveConnectConfigurationId: str?, createdAt: num, customerSupportCodeVisibility: bool, crons: map{enabledAt: num, disabledAt: num?, updatedAt: num, deploymentId: str?, definitions: [map]}, dataCache: map{userDisabled: bool, storageSizeBytes: num?, unlimited: bool}, delegatedProtection: map?, deploymentExpiration: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, devCommand: str?, directoryListing: bool, installCommand: str?, env: [map], customEnvironments: [map], framework: str?, gitForkProtection: bool, gitLFS: bool, id: str, ipBuckets: [map], jobs: map{lint: map{targets: [str]}, typecheck: map{targets: [str]}}, latestDeployments: [map], link: any, microfrontends: any, name: str, nodeVersion: str, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passwordProtection: map?, productionDeploymentsFastLane: bool, publicSource: bool?, resourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rollbackDescription: map{userId: str, username: str, description: str, createdAt: num}, rollingRelease: map?{target: str, stages: [map]?, canaryResponseHeader: bool}, defaultResourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rootDirectory: str?, serverlessFunctionZeroConfigFailover: bool, skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skewProtectionAllowedDomains: [str], skipGitConnectDuringLink: bool, staticIps: map{builds: bool, enabled: bool, regions: [str]}, sourceFilesOutsideRootDirectory: bool, enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, ssoProtection: map?{deploymentType: str, cve55182MigrationAppliedFrom: str?}, targets: map, transferCompletedAt: num, transferStartedAt: num, transferToAccountId: str, transferredFromAccountId: str, updatedAt: num, live: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, permissions: map{oauth2Connection: [str], user: [str], userConnection: [str], userPreference: [str], userSudo: [str], webAuthn: [str], accessGroup: [str], agent: [str], aiGatewayUsage: [str], alerts: [str], alertRules: [str], aliasGlobal: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], oauth2Application: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], auditLog: [str], billingAddress: [str], billingInformation: [str], billingInvoice: [str], billingInvoiceEmailRecipient: [str], billingInvoiceLanguage: [str], billingPlan: [str], billingPurchaseOrder: [str], billingRefund: [str], billingTaxId: [str], blob: [str], blobStoreTokenSet: [str], budget: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], codeChecks: [str], ciInvocations: [str], ciLogs: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], buildMachineDefault: [str], dataCacheBillingSettings: [str], defaultDeploymentProtection: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStrict: [str], integrationStoreTokenSet: [str], integrationVercelConfigurationOverride: [str], integrationPullRequest: [str], ipBlocking: [str], jobGlobal: [str], logDrain: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceInstallationMember: [str], marketplaceInvoice: [str], marketplaceSettings: [str], Monitoring: [str], monitoringAlert: [str], monitoringChart: [str], monitoringQuery: [str], monitoringSettings: [str], notificationCustomerBudget: [str], notificationDeploymentFailed: [str], notificationDomainConfiguration: [str], notificationDomainExpire: [str], notificationDomainMoved: [str], notificationDomainPurchase: [str], notificationDomainRenewal: [str], notificationDomainTransfer: [str], notificationDomainUnverified: [str], NotificationMonitoringAlert: [str], notificationPaymentFailed: [str], notificationPreferences: [str], notificationStatementOfReasons: [str], notificationUsageAlert: [str], observabilityConfiguration: [str], observabilityFunnel: [str], observabilityNotebook: [str], openTelemetryEndpoint: [str], ownEvent: [str], organization: [str], organizationDomain: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], projectTransferIn: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], secret: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], space: [str], spaceRun: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], token: [str], toolbarComment: [str], usage: [str], usageCycle: [str], vercelRun: [str], vercelRunExec: [str], vpcPeeringConnection: [str], webAnalyticsPlan: [str], webhook: [str], webhook-event: [str], aliasProject: [str], aliasProtectionBypass: [str], bulkRedirects: [str], buildMachine: [str], connectConfigurationLink: [str], dataCacheNamespace: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentProductionGit: [str], deploymentV0: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentPromote: [str], deploymentRollback: [str], edgeCacheNamespace: [str], environments: [str], job: [str], logs: [str], logsPreset: [str], observabilityData: [str], onDemandBuild: [str], onDemandConcurrency: [str], optionsAllowlist: [str], passwordProtection: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDelegatedProtection: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectEvent: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectFlags: [str], projectFlagsProduction: [str], projectFromV0: [str], projectId: [str], projectIntegrationConfiguration: [str], projectLink: [str], projectMember: [str], projectMonitoring: [str], projectOIDCToken: [str], projectPermissions: [str], projectProductionBranch: [str], projectProtectionBypass: [str], projectRollingRelease: [str], projectRoutes: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferOut: [str], projectUsage: [str], seawallConfig: [str], sharedEnvVarConnection: [str], skewProtection: [str], analytics: [str], trustedIps: [str], v0Chat: [str], webAnalytics: [str]}, lastRollbackTarget: map?, lastAliasRequest: map?{fromDeploymentId: str?, toDeploymentId: str, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, type: str}, protectionBypass: map, hasActiveBranches: bool, trustedIps: any?, gitComments: map{onPullRequest: bool, onCommit: bool}, gitProviderOptions: map{createDeployments: str, disableRepositoryDispatchEvents: bool, requireVerifiedCommits: bool, consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}}, paused: bool, concurrencyBucketName: str, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}, security: map{attackModeEnabled: bool, attackModeUpdatedAt: num, firewallEnabled: bool, firewallUpdatedAt: num, attackModeActiveUntil: num?, firewallConfigVersion: num, firewallSeawallEnabled: bool, ja3Enabled: bool, ja4Enabled: bool, firewallBypassIps: [str], managedRules: map?{vercel_ruleset: map{active: bool, action: str}, bot_filter: map{active: bool, action: str}, ai_bots: map{active: bool, action: str}, owasp: map{active: bool, action: str}}, botIdEnabled: bool, log_headers: any, securityPlus: bool}, oidcTokenConfig: map{enabled: bool, issuerMode: str}, tier: str, flatRateTier: str, usageStatus: map{kind: str, exceededAllowanceUntil: num, bypassThrottleUntil: num}, features: map{webAnalytics: bool}, v0: bool, v0Created: bool, abuse: map{scanner: str, history: [map], updatedAt: num, block: map{action: str, reason: str, statusCode: num, createdAt: num, caseId: str, actor: str, comment: str, ineligibleForAppeal: bool, isCascading: bool}, blockHistory: [any], interstitial: bool}, internalRoutes: [any], hasDeployments: bool, dismissedToasts: [map], protectedSourcemaps: bool, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}}
@errors {400, 401, 402, 403, 404, 409, 428, 429, 500}

@endpoint GET /v9/projects/{idOrName}
@required {idOrName: any}
@optional {teamId: str, slug: str}
@returns(200) {integrations: [map], accountId: str, analytics: map{id: str, canceledAt: num?, disabledAt: num, enabledAt: num, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, autoExposeSystemEnvs: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, buildCommand: str?, commandForIgnoringBuildStep: str?, connectConfigurations: [map]?, connectConfigurationId: str?, connectBuildsEnabled: bool, passiveConnectConfigurationId: str?, createdAt: num, customerSupportCodeVisibility: bool, crons: map{enabledAt: num, disabledAt: num?, updatedAt: num, deploymentId: str?, definitions: [map]}, dataCache: map{userDisabled: bool, storageSizeBytes: num?, unlimited: bool}, delegatedProtection: map?, deploymentExpiration: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, devCommand: str?, directoryListing: bool, installCommand: str?, env: [map], customEnvironments: [map], framework: str?, gitForkProtection: bool, gitLFS: bool, id: str, ipBuckets: [map], jobs: map{lint: map{targets: [str]}, typecheck: map{targets: [str]}}, latestDeployments: [map], link: any, microfrontends: any, name: str, nodeVersion: str, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passwordProtection: map?, productionDeploymentsFastLane: bool, publicSource: bool?, resourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rollbackDescription: map{userId: str, username: str, description: str, createdAt: num}, rollingRelease: map?{target: str, stages: [map]?, canaryResponseHeader: bool}, defaultResourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rootDirectory: str?, serverlessFunctionZeroConfigFailover: bool, skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skewProtectionAllowedDomains: [str], skipGitConnectDuringLink: bool, staticIps: map{builds: bool, enabled: bool, regions: [str]}, sourceFilesOutsideRootDirectory: bool, enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, ssoProtection: map?{deploymentType: str, cve55182MigrationAppliedFrom: str?}, targets: map, transferCompletedAt: num, transferStartedAt: num, transferToAccountId: str, transferredFromAccountId: str, updatedAt: num, live: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, permissions: map{oauth2Connection: [str], user: [str], userConnection: [str], userPreference: [str], userSudo: [str], webAuthn: [str], accessGroup: [str], agent: [str], aiGatewayUsage: [str], alerts: [str], alertRules: [str], aliasGlobal: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], oauth2Application: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], auditLog: [str], billingAddress: [str], billingInformation: [str], billingInvoice: [str], billingInvoiceEmailRecipient: [str], billingInvoiceLanguage: [str], billingPlan: [str], billingPurchaseOrder: [str], billingRefund: [str], billingTaxId: [str], blob: [str], blobStoreTokenSet: [str], budget: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], codeChecks: [str], ciInvocations: [str], ciLogs: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], buildMachineDefault: [str], dataCacheBillingSettings: [str], defaultDeploymentProtection: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStrict: [str], integrationStoreTokenSet: [str], integrationVercelConfigurationOverride: [str], integrationPullRequest: [str], ipBlocking: [str], jobGlobal: [str], logDrain: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceInstallationMember: [str], marketplaceInvoice: [str], marketplaceSettings: [str], Monitoring: [str], monitoringAlert: [str], monitoringChart: [str], monitoringQuery: [str], monitoringSettings: [str], notificationCustomerBudget: [str], notificationDeploymentFailed: [str], notificationDomainConfiguration: [str], notificationDomainExpire: [str], notificationDomainMoved: [str], notificationDomainPurchase: [str], notificationDomainRenewal: [str], notificationDomainTransfer: [str], notificationDomainUnverified: [str], NotificationMonitoringAlert: [str], notificationPaymentFailed: [str], notificationPreferences: [str], notificationStatementOfReasons: [str], notificationUsageAlert: [str], observabilityConfiguration: [str], observabilityFunnel: [str], observabilityNotebook: [str], openTelemetryEndpoint: [str], ownEvent: [str], organization: [str], organizationDomain: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], projectTransferIn: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], secret: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], space: [str], spaceRun: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], token: [str], toolbarComment: [str], usage: [str], usageCycle: [str], vercelRun: [str], vercelRunExec: [str], vpcPeeringConnection: [str], webAnalyticsPlan: [str], webhook: [str], webhook-event: [str], aliasProject: [str], aliasProtectionBypass: [str], bulkRedirects: [str], buildMachine: [str], connectConfigurationLink: [str], dataCacheNamespace: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentProductionGit: [str], deploymentV0: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentPromote: [str], deploymentRollback: [str], edgeCacheNamespace: [str], environments: [str], job: [str], logs: [str], logsPreset: [str], observabilityData: [str], onDemandBuild: [str], onDemandConcurrency: [str], optionsAllowlist: [str], passwordProtection: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDelegatedProtection: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectEvent: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectFlags: [str], projectFlagsProduction: [str], projectFromV0: [str], projectId: [str], projectIntegrationConfiguration: [str], projectLink: [str], projectMember: [str], projectMonitoring: [str], projectOIDCToken: [str], projectPermissions: [str], projectProductionBranch: [str], projectProtectionBypass: [str], projectRollingRelease: [str], projectRoutes: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferOut: [str], projectUsage: [str], seawallConfig: [str], sharedEnvVarConnection: [str], skewProtection: [str], analytics: [str], trustedIps: [str], v0Chat: [str], webAnalytics: [str]}, lastRollbackTarget: map?, lastAliasRequest: map?{fromDeploymentId: str?, toDeploymentId: str, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, type: str}, protectionBypass: map, hasActiveBranches: bool, trustedIps: any?, gitComments: map{onPullRequest: bool, onCommit: bool}, gitProviderOptions: map{createDeployments: str, disableRepositoryDispatchEvents: bool, requireVerifiedCommits: bool, consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}}, paused: bool, concurrencyBucketName: str, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}, security: map{attackModeEnabled: bool, attackModeUpdatedAt: num, firewallEnabled: bool, firewallUpdatedAt: num, attackModeActiveUntil: num?, firewallConfigVersion: num, firewallSeawallEnabled: bool, ja3Enabled: bool, ja4Enabled: bool, firewallBypassIps: [str], managedRules: map?{vercel_ruleset: map{active: bool, action: str}, bot_filter: map{active: bool, action: str}, ai_bots: map{active: bool, action: str}, owasp: map{active: bool, action: str}}, botIdEnabled: bool, log_headers: any, securityPlus: bool}, oidcTokenConfig: map{enabled: bool, issuerMode: str}, tier: str, flatRateTier: str, usageStatus: map{kind: str, exceededAllowanceUntil: num, bypassThrottleUntil: num}, features: map{webAnalytics: bool}, v0: bool, v0Created: bool, abuse: map{scanner: str, history: [map], updatedAt: num, block: map{action: str, reason: str, statusCode: num, createdAt: num, caseId: str, actor: str, comment: str, ineligibleForAppeal: bool, isCascading: bool}, blockHistory: [any], interstitial: bool}, internalRoutes: [any], hasDeployments: bool, dismissedToasts: [map], protectedSourcemaps: bool, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}}
@errors {400, 401, 403}

@endpoint PATCH /v9/projects/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str, autoExposeSystemEnvs: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, buildCommand: str, commandForIgnoringBuildStep: str, customerSupportCodeVisibility: bool, devCommand: str, directoryListing: bool, framework: str(services/blitzjs/nextjs/gatsby/remix/react-router/astro/hexo/eleventy/docusaurus-2/docusaurus/preact/solidstart-1/solidstart/dojo/ember/vue/scully/ionic-angular/angular/polymer/svelte/sveltekit/sveltekit-1/ionic-react/create-react-app/gridsome/umijs/sapper/saber/stencil/nuxtjs/redwoodjs/hugo/jekyll/brunch/middleman/zola/hydrogen/vite/tanstack-start/vitepress/vuepress/parcel/fastapi/flask/fasthtml/django/sanity-v3/sanity/storybook/nitro/hono/express/h3/koa/nestjs/elysia/fastify/xmcp/python/ruby/rust/node/go), gitForkProtection: bool, gitLFS: bool, protectedSourcemaps: bool, installCommand: str, name: str, nodeVersion: str(24.x/22.x/20.x/18.x/16.x/14.x/12.x/10.x), outputDirectory: str, previewDeploymentsDisabled: bool, previewDeploymentSuffix: str, publicSource: bool, resourceConfig: map{buildMachineType: any, buildQueue: map, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: any, functionZeroConfigFailover: any, elasticConcurrencyEnabled: bool, buildMachineSelection: any, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool}, rootDirectory: str, serverlessFunctionRegion: str, serverlessFunctionZeroConfigFailover: any, skewProtectionBoundaryAt: int, skewProtectionMaxAge: int, skewProtectionAllowedDomains: [str], skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, enablePreviewFeedback: bool, enableProductionFeedback: bool, enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, staticIps: map{enabled!: bool}, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, oidcTokenConfig: map{enabled: bool, issuerMode: str}, passwordProtection: map{deploymentType!: str, password: str}, ssoProtection: map{deploymentType!: str}, trustedIps: map{deploymentType!: str, addresses!: [map], protectionMode!: str}, optionsAllowlist: map{paths!: [map]}, connectConfigurations: [any], dismissedToasts: [map{key!: str, dismissedAt!: num, action!: any, value!: any}]}
@returns(200) {accountId: str, analytics: map{id: str, canceledAt: num?, disabledAt: num, enabledAt: num, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, autoExposeSystemEnvs: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, buildCommand: str?, commandForIgnoringBuildStep: str?, connectConfigurations: [map]?, connectConfigurationId: str?, connectBuildsEnabled: bool, passiveConnectConfigurationId: str?, createdAt: num, customerSupportCodeVisibility: bool, crons: map{enabledAt: num, disabledAt: num?, updatedAt: num, deploymentId: str?, definitions: [map]}, dataCache: map{userDisabled: bool, storageSizeBytes: num?, unlimited: bool}, delegatedProtection: map?, deploymentExpiration: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, devCommand: str?, directoryListing: bool, installCommand: str?, env: [map], customEnvironments: [map], framework: str?, gitForkProtection: bool, gitLFS: bool, id: str, ipBuckets: [map], jobs: map{lint: map{targets: [str]}, typecheck: map{targets: [str]}}, latestDeployments: [map], link: any, microfrontends: any, name: str, nodeVersion: str, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passwordProtection: map?, productionDeploymentsFastLane: bool, publicSource: bool?, resourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rollbackDescription: map{userId: str, username: str, description: str, createdAt: num}, rollingRelease: map?{target: str, stages: [map]?, canaryResponseHeader: bool}, defaultResourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rootDirectory: str?, serverlessFunctionZeroConfigFailover: bool, skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skewProtectionAllowedDomains: [str], skipGitConnectDuringLink: bool, staticIps: map{builds: bool, enabled: bool, regions: [str]}, sourceFilesOutsideRootDirectory: bool, enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, ssoProtection: map?{deploymentType: str, cve55182MigrationAppliedFrom: str?}, targets: map, transferCompletedAt: num, transferStartedAt: num, transferToAccountId: str, transferredFromAccountId: str, updatedAt: num, live: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, permissions: map{oauth2Connection: [str], user: [str], userConnection: [str], userPreference: [str], userSudo: [str], webAuthn: [str], accessGroup: [str], agent: [str], aiGatewayUsage: [str], alerts: [str], alertRules: [str], aliasGlobal: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], oauth2Application: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], auditLog: [str], billingAddress: [str], billingInformation: [str], billingInvoice: [str], billingInvoiceEmailRecipient: [str], billingInvoiceLanguage: [str], billingPlan: [str], billingPurchaseOrder: [str], billingRefund: [str], billingTaxId: [str], blob: [str], blobStoreTokenSet: [str], budget: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], codeChecks: [str], ciInvocations: [str], ciLogs: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], buildMachineDefault: [str], dataCacheBillingSettings: [str], defaultDeploymentProtection: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStrict: [str], integrationStoreTokenSet: [str], integrationVercelConfigurationOverride: [str], integrationPullRequest: [str], ipBlocking: [str], jobGlobal: [str], logDrain: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceInstallationMember: [str], marketplaceInvoice: [str], marketplaceSettings: [str], Monitoring: [str], monitoringAlert: [str], monitoringChart: [str], monitoringQuery: [str], monitoringSettings: [str], notificationCustomerBudget: [str], notificationDeploymentFailed: [str], notificationDomainConfiguration: [str], notificationDomainExpire: [str], notificationDomainMoved: [str], notificationDomainPurchase: [str], notificationDomainRenewal: [str], notificationDomainTransfer: [str], notificationDomainUnverified: [str], NotificationMonitoringAlert: [str], notificationPaymentFailed: [str], notificationPreferences: [str], notificationStatementOfReasons: [str], notificationUsageAlert: [str], observabilityConfiguration: [str], observabilityFunnel: [str], observabilityNotebook: [str], openTelemetryEndpoint: [str], ownEvent: [str], organization: [str], organizationDomain: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], projectTransferIn: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], secret: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], space: [str], spaceRun: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], token: [str], toolbarComment: [str], usage: [str], usageCycle: [str], vercelRun: [str], vercelRunExec: [str], vpcPeeringConnection: [str], webAnalyticsPlan: [str], webhook: [str], webhook-event: [str], aliasProject: [str], aliasProtectionBypass: [str], bulkRedirects: [str], buildMachine: [str], connectConfigurationLink: [str], dataCacheNamespace: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentProductionGit: [str], deploymentV0: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentPromote: [str], deploymentRollback: [str], edgeCacheNamespace: [str], environments: [str], job: [str], logs: [str], logsPreset: [str], observabilityData: [str], onDemandBuild: [str], onDemandConcurrency: [str], optionsAllowlist: [str], passwordProtection: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDelegatedProtection: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectEvent: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectFlags: [str], projectFlagsProduction: [str], projectFromV0: [str], projectId: [str], projectIntegrationConfiguration: [str], projectLink: [str], projectMember: [str], projectMonitoring: [str], projectOIDCToken: [str], projectPermissions: [str], projectProductionBranch: [str], projectProtectionBypass: [str], projectRollingRelease: [str], projectRoutes: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferOut: [str], projectUsage: [str], seawallConfig: [str], sharedEnvVarConnection: [str], skewProtection: [str], analytics: [str], trustedIps: [str], v0Chat: [str], webAnalytics: [str]}, lastRollbackTarget: map?, lastAliasRequest: map?{fromDeploymentId: str?, toDeploymentId: str, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, type: str}, protectionBypass: map, hasActiveBranches: bool, trustedIps: any?, gitComments: map{onPullRequest: bool, onCommit: bool}, gitProviderOptions: map{createDeployments: str, disableRepositoryDispatchEvents: bool, requireVerifiedCommits: bool, consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}}, paused: bool, concurrencyBucketName: str, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}, security: map{attackModeEnabled: bool, attackModeUpdatedAt: num, firewallEnabled: bool, firewallUpdatedAt: num, attackModeActiveUntil: num?, firewallConfigVersion: num, firewallSeawallEnabled: bool, ja3Enabled: bool, ja4Enabled: bool, firewallBypassIps: [str], managedRules: map?{vercel_ruleset: map{active: bool, action: str}, bot_filter: map{active: bool, action: str}, ai_bots: map{active: bool, action: str}, owasp: map{active: bool, action: str}}, botIdEnabled: bool, log_headers: any, securityPlus: bool}, oidcTokenConfig: map{enabled: bool, issuerMode: str}, tier: str, flatRateTier: str, usageStatus: map{kind: str, exceededAllowanceUntil: num, bypassThrottleUntil: num}, features: map{webAnalytics: bool}, v0: bool, v0Created: bool, abuse: map{scanner: str, history: [map], updatedAt: num, block: map{action: str, reason: str, statusCode: num, createdAt: num, caseId: str, actor: str, comment: str, ineligibleForAppeal: bool, isCascading: bool}, blockHistory: [any], interstitial: bool}, internalRoutes: [any], hasDeployments: bool, dismissedToasts: [map], protectedSourcemaps: bool, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}}
@errors {400, 401, 402, 403, 404, 409, 428}

@endpoint DELETE /v9/projects/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 409}

@endpoint PATCH /v1/projects/{idOrName}/shared-connect-links
@required {idOrName: str}
@optional {teamId: str, slug: str, builds: bool, regions: [str]}
@returns(200)
@errors {400, 401, 402, 403, 404, 409, 500}

@endpoint POST /v9/projects/{idOrName}/custom-environments
@required {idOrName: str}
@optional {teamId: str, slug: str, slug: str, description: str, branchMatcher: map{type!: any, pattern!: str}, copyEnvVarsFrom: str}
@returns(201) {id: str, slug: str, type: str, description: str, branchMatcher: map{type: str, pattern: str}, domains: [map], currentDeploymentAliases: [str], createdAt: num, updatedAt: num}
@errors {400, 401, 402, 403, 500}

@endpoint GET /v9/projects/{idOrName}/custom-environments
@required {idOrName: str}
@optional {gitBranch: str, teamId: str, slug: str}
@returns(200) {accountLimit: map{total: num}, environments: [map]}
@errors {400, 401, 403}

@endpoint GET /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}
@required {idOrName: str, environmentSlugOrId: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, slug: str, type: str, description: str, branchMatcher: map{type: str, pattern: str}, domains: [map], currentDeploymentAliases: [str], createdAt: num, updatedAt: num}
@errors {400, 401, 403, 404}

@endpoint PATCH /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}
@required {idOrName: str, environmentSlugOrId: str}
@optional {teamId: str, slug: str, slug: str, description: str, branchMatcher: map{type!: any, pattern!: str}}
@returns(200) {id: str, slug: str, type: str, description: str, branchMatcher: map{type: str, pattern: str}, domains: [map], currentDeploymentAliases: [str], createdAt: num, updatedAt: num}
@errors {400, 401, 402, 403, 500}

@endpoint DELETE /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}
@required {idOrName: str, environmentSlugOrId: str}
@optional {teamId: str, slug: str, deleteUnassignedEnvironmentVariables: bool}
@returns(200) {id: str, slug: str, type: str, description: str, branchMatcher: map{type: str, pattern: str}, domains: [map], currentDeploymentAliases: [str], createdAt: num, updatedAt: num}
@errors {400, 401, 403}

@endpoint GET /v9/projects/{idOrName}/domains
@required {idOrName: any}
@optional {production: any(true/false)=false, target: str(production/preview), customEnvironmentId: str, gitBranch: str, redirects: any(true/false)=true, redirect: str, verified: any(true/false), limit: num, since: num, until: num, order: any(ASC/DESC)=DESC, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v9/projects/{idOrName}/domains/{domain}
@required {idOrName: str, domain: str}
@optional {teamId: str, slug: str}
@returns(200) {name: str, apexName: str, projectId: str, redirect: str?, redirectStatusCode: num?, gitBranch: str?, customEnvironmentId: str?, updatedAt: num, createdAt: num, verified: bool, verification: [map]}
@errors {400, 401, 403}

@endpoint PATCH /v9/projects/{idOrName}/domains/{domain}
@required {idOrName: str, domain: str}
@optional {teamId: str, slug: str, gitBranch: str, redirect: str, redirectStatusCode: int(301/302/307/308)}
@returns(200) {name: str, apexName: str, projectId: str, redirect: str?, redirectStatusCode: num?, gitBranch: str?, customEnvironmentId: str?, updatedAt: num, createdAt: num, verified: bool, verification: [map]}
@errors {400, 401, 403, 409}

@endpoint DELETE /v9/projects/{idOrName}/domains/{domain}
@required {idOrName: str, domain: str}
@optional {teamId: str, slug: str, removeRedirects: bool}
@returns(200)
@errors {400, 401, 403, 404, 409}

@endpoint POST /v10/projects/{idOrName}/domains
@required {idOrName: str, name: str}
@optional {teamId: str, slug: str, gitBranch: str, customEnvironmentId: str, redirect: str, redirectStatusCode: int(301/302/307/308)}
@returns(200) {name: str, apexName: str, projectId: str, redirect: str?, redirectStatusCode: num?, gitBranch: str?, customEnvironmentId: str?, updatedAt: num, createdAt: num, verified: bool, verification: [map]}
@errors {400, 401, 402, 403, 409}

@endpoint POST /v1/projects/{idOrName}/domains/{domain}/move
@required {idOrName: str, domain: str, projectId: any}
@optional {teamId: str, slug: str, gitBranch: str, redirect: str, redirectStatusCode: int(301/302/307/308)}
@returns(200) {name: str, apexName: str, projectId: str, redirect: str?, redirectStatusCode: num?, gitBranch: str?, customEnvironmentId: str?, updatedAt: num, createdAt: num, verified: bool, verification: [map]}
@errors {400, 401, 403, 409}

@endpoint POST /v9/projects/{idOrName}/domains/{domain}/verify
@required {idOrName: str, domain: str}
@optional {teamId: str, slug: str}
@returns(200) {name: str, apexName: str, projectId: str, redirect: str?, redirectStatusCode: num?, gitBranch: str?, customEnvironmentId: str?, updatedAt: num, createdAt: num, verified: bool}
@errors {400, 401, 403}

@endpoint GET /v10/projects/{idOrName}/env
@required {idOrName: str}
@optional {gitBranch: str, decrypt: str(true/false), source: str, customEnvironmentId: str, customEnvironmentSlug: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v10/projects/{idOrName}/env
@required {idOrName: str}
@optional {upsert: str, teamId: str, slug: str}
@returns(201) {created: any, failed: [map]}
@errors {400, 401, 402, 403, 404, 409, 429, 500}

@endpoint GET /v1/projects/{idOrName}/env/{id}
@required {idOrName: str, id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint DELETE /v9/projects/{idOrName}/env/{id}
@required {idOrName: str, id: str}
@optional {customEnvironmentId: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 409}

@endpoint PATCH /v9/projects/{idOrName}/env/{id}
@required {idOrName: str, id: str}
@optional {teamId: str, slug: str, key: str, target: [any], gitBranch: str, type: str(system/encrypted/plain/sensitive), value: str, customEnvironmentIds: [str], comment: str}
@returns(200) {type: str, value: str, edgeConfigId: str?, edgeConfigTokenId: str?, createdAt: num, updatedAt: num, id: str, createdBy: str?, target: any, key: str, gitBranch: str, updatedBy: str?, sunsetSecretId: str, legacyValue: str, decrypted: bool, configurationId: str?, contentHint: any?, internalContentHint: map?{type: str, encryptedValue: str}, comment: str, customEnvironmentIds: [str]}
@errors {400, 401, 403, 404, 409, 429, 500}

@endpoint DELETE /v1/projects/{idOrName}/env
@required {idOrName: str, ids: [str]}
@optional {teamId: str, slug: str}
@returns(200) {deleted: num, ids: [str]}
@errors {400, 401, 403, 404, 409}

@endpoint GET /v1/projects/{idOrName}/rolling-release/billing
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v1/projects/{idOrName}/rolling-release/config
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {rollingRelease: map?{target: str, stages: [map]?, canaryResponseHeader: bool}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/projects/{idOrName}/rolling-release/config
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {rollingRelease: any?}
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/projects/{idOrName}/rolling-release/config
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v1/projects/{idOrName}/rolling-release
@required {idOrName: str}
@optional {state: str(ACTIVE/COMPLETE/ABORTED), teamId: str, slug: str}
@returns(200) {rollingRelease: map?{state: str, currentDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, canaryDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, queuedDeploymentId: str?, advancementType: str, stages: [map], activeStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, nextStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, startedAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint POST /v1/projects/{idOrName}/rolling-release/approve-stage
@required {idOrName: str, nextStageIndex: num, canaryDeploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {rollingRelease: map?{state: str, currentDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, canaryDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, queuedDeploymentId: str?, advancementType: str, stages: [map], activeStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, nextStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, startedAt: num, updatedAt: num}}
@errors {400, 401, 403, 404, 500}

@endpoint POST /v1/projects/{idOrName}/rolling-release/complete
@required {idOrName: str, canaryDeploymentId: str}
@optional {teamId: str, slug: str}
@returns(200) {rollingRelease: map?{state: str, currentDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, canaryDeployment: map?{name: str, createdAt: num, id: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, queuedDeploymentId: str?, advancementType: str, stages: [map], activeStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, nextStage: map?{index: num, isFinalStage: bool, targetPercentage: num, requireApproval: bool, duration: num?, linearShift: bool}, startedAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint POST /projects/{idOrName}/transfer-request
@required {idOrName: str}
@optional {teamId: str, slug: str, callbackUrl: str, callbackSecret: str}
@returns(200) {code: str}
@errors {400, 401, 403}

@endpoint PUT /projects/transfer-request/{code}
@required {code: str}
@optional {teamId: str, slug: str, newProjectName: str, paidFeatures: map{concurrentBuilds: int, passwordProtection: bool, previewDeploymentSuffix: bool}, acceptedPolicies: map}
@returns(202)
@errors {400, 401, 403, 404, 422}

@endpoint PATCH /v1/projects/{idOrName}/protection-bypass
@required {idOrName: str}
@optional {teamId: str, slug: str, revoke: map{secret!: str, regenerate!: bool}, generate: map{secret: str, note: str}, update: map{secret!: str, isEnvVar: bool, note: str}}
@returns(200) {protectionBypass: map}
@errors {400, 401, 403, 404, 409}

@endpoint POST /v1/projects/{projectId}/rollback/{deploymentId}
@required {projectId: str, deploymentId: str}
@optional {description: str, teamId: str, slug: str}
@returns(201)
@errors {400, 401, 402, 403, 409, 422}

@endpoint PATCH /v1/projects/{projectId}/rollback/{deploymentId}/update-description
@required {projectId: str, deploymentId: str}
@optional {description: str}
@returns(200)
@errors {400, 401, 403, 409, 422}

@endpoint PATCH /v1/projects/{projectId}/microfrontends
@required {projectId: str}
@optional {teamId: str, slug: str, microfrontendsGroupId: str, enabled: bool, isDefaultApp: bool, defaultRoute: str, routeObservabilityToThisProject: bool, doNotRouteWithMicrofrontendsRouting: bool}
@returns(200) {accountId: str, analytics: map{id: str, canceledAt: num?, disabledAt: num, enabledAt: num, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, speedInsights: map{id: str, enabledAt: num, disabledAt: num, canceledAt: num, hasData: bool, paidAt: num}, autoExposeSystemEnvs: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, buildCommand: str?, commandForIgnoringBuildStep: str?, connectConfigurations: [map]?, connectConfigurationId: str?, connectBuildsEnabled: bool, passiveConnectConfigurationId: str?, createdAt: num, customerSupportCodeVisibility: bool, crons: map{enabledAt: num, disabledAt: num?, updatedAt: num, deploymentId: str?, definitions: [map]}, dataCache: map{userDisabled: bool, storageSizeBytes: num?, unlimited: bool}, delegatedProtection: map?, deploymentExpiration: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, devCommand: str?, directoryListing: bool, installCommand: str?, env: [map], customEnvironments: [map], framework: str?, gitForkProtection: bool, gitLFS: bool, id: str, ipBuckets: [map], jobs: map{lint: map{targets: [str]}, typecheck: map{targets: [str]}}, latestDeployments: [map], link: any, microfrontends: any, name: str, nodeVersion: str, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passwordProtection: map?, productionDeploymentsFastLane: bool, publicSource: bool?, resourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rollbackDescription: map{userId: str, username: str, description: str, createdAt: num}, rollingRelease: map?{target: str, stages: [map]?, canaryResponseHeader: bool}, defaultResourceConfig: map{elasticConcurrencyEnabled: bool, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: str, functionZeroConfigFailover: bool, buildMachineType: str, buildMachineSelection: str, buildMachineElasticLastUpdated: num, isNSNBDisabled: bool, buildQueue: map{configuration: str}}, rootDirectory: str?, serverlessFunctionZeroConfigFailover: bool, skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skewProtectionAllowedDomains: [str], skipGitConnectDuringLink: bool, staticIps: map{builds: bool, enabled: bool, regions: [str]}, sourceFilesOutsideRootDirectory: bool, enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, ssoProtection: map?{deploymentType: str, cve55182MigrationAppliedFrom: str?}, targets: map, transferCompletedAt: num, transferStartedAt: num, transferToAccountId: str, transferredFromAccountId: str, updatedAt: num, live: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, permissions: map{oauth2Connection: [str], user: [str], userConnection: [str], userPreference: [str], userSudo: [str], webAuthn: [str], accessGroup: [str], agent: [str], aiGatewayUsage: [str], alerts: [str], alertRules: [str], aliasGlobal: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], oauth2Application: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], auditLog: [str], billingAddress: [str], billingInformation: [str], billingInvoice: [str], billingInvoiceEmailRecipient: [str], billingInvoiceLanguage: [str], billingPlan: [str], billingPurchaseOrder: [str], billingRefund: [str], billingTaxId: [str], blob: [str], blobStoreTokenSet: [str], budget: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], codeChecks: [str], ciInvocations: [str], ciLogs: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], buildMachineDefault: [str], dataCacheBillingSettings: [str], defaultDeploymentProtection: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStrict: [str], integrationStoreTokenSet: [str], integrationVercelConfigurationOverride: [str], integrationPullRequest: [str], ipBlocking: [str], jobGlobal: [str], logDrain: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceInstallationMember: [str], marketplaceInvoice: [str], marketplaceSettings: [str], Monitoring: [str], monitoringAlert: [str], monitoringChart: [str], monitoringQuery: [str], monitoringSettings: [str], notificationCustomerBudget: [str], notificationDeploymentFailed: [str], notificationDomainConfiguration: [str], notificationDomainExpire: [str], notificationDomainMoved: [str], notificationDomainPurchase: [str], notificationDomainRenewal: [str], notificationDomainTransfer: [str], notificationDomainUnverified: [str], NotificationMonitoringAlert: [str], notificationPaymentFailed: [str], notificationPreferences: [str], notificationStatementOfReasons: [str], notificationUsageAlert: [str], observabilityConfiguration: [str], observabilityFunnel: [str], observabilityNotebook: [str], openTelemetryEndpoint: [str], ownEvent: [str], organization: [str], organizationDomain: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], projectTransferIn: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], secret: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], space: [str], spaceRun: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], token: [str], toolbarComment: [str], usage: [str], usageCycle: [str], vercelRun: [str], vercelRunExec: [str], vpcPeeringConnection: [str], webAnalyticsPlan: [str], webhook: [str], webhook-event: [str], aliasProject: [str], aliasProtectionBypass: [str], bulkRedirects: [str], buildMachine: [str], connectConfigurationLink: [str], dataCacheNamespace: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentProductionGit: [str], deploymentV0: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentPromote: [str], deploymentRollback: [str], edgeCacheNamespace: [str], environments: [str], job: [str], logs: [str], logsPreset: [str], observabilityData: [str], onDemandBuild: [str], onDemandConcurrency: [str], optionsAllowlist: [str], passwordProtection: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDelegatedProtection: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectEvent: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectFlags: [str], projectFlagsProduction: [str], projectFromV0: [str], projectId: [str], projectIntegrationConfiguration: [str], projectLink: [str], projectMember: [str], projectMonitoring: [str], projectOIDCToken: [str], projectPermissions: [str], projectProductionBranch: [str], projectProtectionBypass: [str], projectRollingRelease: [str], projectRoutes: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferOut: [str], projectUsage: [str], seawallConfig: [str], sharedEnvVarConnection: [str], skewProtection: [str], analytics: [str], trustedIps: [str], v0Chat: [str], webAnalytics: [str]}, lastRollbackTarget: map?, lastAliasRequest: map?{fromDeploymentId: str?, toDeploymentId: str, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, type: str}, protectionBypass: map, hasActiveBranches: bool, trustedIps: any?, gitComments: map{onPullRequest: bool, onCommit: bool}, gitProviderOptions: map{createDeployments: str, disableRepositoryDispatchEvents: bool, requireVerifiedCommits: bool, consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}}, paused: bool, concurrencyBucketName: str, webAnalytics: map{id: str, disabledAt: num, canceledAt: num, enabledAt: num, hasData: bool}, security: map{attackModeEnabled: bool, attackModeUpdatedAt: num, firewallEnabled: bool, firewallUpdatedAt: num, attackModeActiveUntil: num?, firewallConfigVersion: num, firewallSeawallEnabled: bool, ja3Enabled: bool, ja4Enabled: bool, firewallBypassIps: [str], managedRules: map?{vercel_ruleset: map{active: bool, action: str}, bot_filter: map{active: bool, action: str}, ai_bots: map{active: bool, action: str}, owasp: map{active: bool, action: str}}, botIdEnabled: bool, log_headers: any, securityPlus: bool}, oidcTokenConfig: map{enabled: bool, issuerMode: str}, tier: str, flatRateTier: str, usageStatus: map{kind: str, exceededAllowanceUntil: num, bypassThrottleUntil: num}, features: map{webAnalytics: bool}, v0: bool, v0Created: bool, abuse: map{scanner: str, history: [map], updatedAt: num, block: map{action: str, reason: str, statusCode: num, createdAt: num, caseId: str, actor: str, comment: str, ineligibleForAppeal: bool, isCascading: bool}, blockHistory: [any], interstitial: bool}, internalRoutes: [any], hasDeployments: bool, dismissedToasts: [map], protectedSourcemaps: bool, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}}
@errors {400, 401, 403, 409, 500}

@endpoint POST /v10/projects/{projectId}/promote/{deploymentId}
@required {projectId: str, deploymentId: str}
@optional {teamId: str, slug: str}
@returns(201)
@returns(202)
@errors {400, 401, 403, 409}

@endpoint GET /v1/projects/{projectId}/promote/aliases
@required {projectId: str}
@optional {limit: num, since: num, until: num, failedOnly: bool, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v1/projects/{projectId}/pause
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 500}

@endpoint POST /v1/projects/{projectId}/unpause
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 500}

@endgroup

@group sandboxes
@endpoint GET /v1/sandboxes
@optional {project: str, limit: num, since: num, until: num, teamId: str, slug: str}
@returns(200) {sandboxes: [map], pagination: map{total: num, count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404}

@endpoint POST /v1/sandboxes
@optional {teamId: str, slug: str, resources: map{vcpus: int, memory: int}, runtime: str(node22/node24/python3.13)=node24, source: any, projectId: str, ports: [int], timeout: int, networkPolicy: map{mode!: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, env: map=[object Object]}
@returns(200) {sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}, routes: [map]}
@errors {400, 401, 402, 403, 404, 410, 422, 429, 500}

@endpoint GET /v1/sandboxes/snapshots
@optional {project: str, limit: num, since: num, until: num, teamId: str, slug: str}
@returns(200) {snapshots: [map], pagination: map{total: num, count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404}

@endpoint GET /v1/sandboxes/{sandboxId}
@required {sandboxId: str}
@optional {teamId: str, slug: str}
@returns(200) {sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}, routes: [map]}
@errors {400, 401, 403, 429}

@endpoint GET /v1/sandboxes/{sandboxId}/cmd
@required {sandboxId: str}
@optional {teamId: str, slug: str}
@returns(200) {commands: [map]}
@errors {400, 401, 403}

@endpoint POST /v1/sandboxes/{sandboxId}/cmd
@required {sandboxId: str, command: str}
@optional {teamId: str, slug: str, args: [str], cwd: str, env: map=[object Object], sudo: bool=false, wait: bool=false}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sandboxId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/{cmdId}/kill
@required {cmdId: str, sandboxId: str, signal: num}
@optional {teamId: str, slug: str}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sandboxId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 404, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/stop
@required {sandboxId: str}
@optional {teamId: str, slug: str}
@returns(200) {sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 403, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/extend-timeout
@required {sandboxId: str, duration: num}
@optional {teamId: str, slug: str}
@returns(200) {sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 403, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/network-policy
@required {sandboxId: str, mode: str(allow-all/deny-all/custom/default-allow/default-deny)}
@optional {teamId: str, slug: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}
@returns(200) {sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 402, 403, 410, 422}

@endpoint GET /v1/sandboxes/{sandboxId}/cmd/{cmdId}
@required {sandboxId: str, cmdId: str}
@optional {wait: str(true/false)=false, teamId: str, slug: str}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sandboxId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 410, 422}

@endpoint GET /v1/sandboxes/{sandboxId}/cmd/{cmdId}/logs
@required {sandboxId: str, cmdId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/fs/read
@required {sandboxId: str, path: str}
@optional {teamId: str, slug: str, cwd: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/fs/mkdir
@required {sandboxId: str, path: str}
@optional {teamId: str, slug: str, cwd: str, recursive: bool=true}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint POST /v1/sandboxes/{sandboxId}/fs/write
@required {sandboxId: str}
@optional {x-cwd: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint GET /v1/sandboxes/snapshots/{snapshotId}
@required {snapshotId: str}
@optional {teamId: str, slug: str}
@returns(200) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/sandboxes/snapshots/{snapshotId}
@required {snapshotId: str}
@optional {teamId: str, slug: str}
@returns(200) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint POST /v1/sandboxes/{sandboxId}/snapshot
@required {sandboxId: str}
@optional {teamId: str, slug: str, expiration: any}
@returns(201) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}, sandbox: map{id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 402, 403, 410, 422}

@endpoint GET /v2/sandboxes
@optional {project: str, limit: num=20, sortBy: str(createdAt/name/statusUpdatedAt)=createdAt, namePrefix: str, cursor: str, sortOrder: str(asc/desc)=desc, tags: any, teamId: str, slug: str}
@returns(200) {sandboxes: [map], pagination: map{count: num, next: str?}}
@errors {400, 401, 403, 404}

@endpoint POST /v2/sandboxes
@optional {teamId: str, slug: str, resources: map{vcpus: int, memory: int}, runtime: str(node22/node24/python3.13)=node24, source: any, projectId: str, ports: [int], timeout: int, networkPolicy: map{mode!: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, env: map=[object Object], name: str, persistent: bool=true, snapshotExpiration: any, tags: map}
@returns(200) {sandbox: map{name: str, currentSnapshotId: str, currentSessionId: str, status: str, statusUpdatedAt: num, persistent: bool, region: str, vcpus: num, memory: num, runtime: str, timeout: num, snapshotExpiration: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, totalEgressBytes: num, totalIngressBytes: num, totalActiveCpuDurationMs: num, totalDurationMs: num, cwd: str, tags: map, createdAt: num, updatedAt: num}, session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}, routes: [map]}
@errors {400, 401, 402, 403, 404, 410, 422, 429, 500}

@endpoint GET /v2/sandboxes/snapshots
@optional {project: str, name: str, limit: num=20, cursor: str, sortOrder: str(asc/desc)=desc, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v2/sandboxes/snapshots/{snapshotId}
@required {snapshotId: str}
@optional {teamId: str, slug: str}
@returns(200) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v2/sandboxes/snapshots/{snapshotId}
@required {snapshotId: str}
@optional {teamId: str, slug: str}
@returns(200) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 404}

@endpoint GET /v2/sandboxes/sessions
@optional {project: str, name: str, limit: num=20, cursor: str, sortOrder: str(asc/desc)=desc, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 500}

@endpoint GET /v2/sandboxes/sessions/{sessionId}
@required {sessionId: str}
@optional {teamId: str, slug: str}
@returns(200) {session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}, routes: [map]}
@errors {400, 401, 403, 500}

@endpoint GET /v2/sandboxes/{name}
@required {name: str}
@optional {projectId: str, resume: bool=false, teamId: str, slug: str}
@returns(200) {sandbox: map{name: str, currentSnapshotId: str, currentSessionId: str, status: str, statusUpdatedAt: num, persistent: bool, region: str, vcpus: num, memory: num, runtime: str, timeout: num, snapshotExpiration: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, totalEgressBytes: num, totalIngressBytes: num, totalActiveCpuDurationMs: num, totalDurationMs: num, cwd: str, tags: map, createdAt: num, updatedAt: num}, session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}, routes: [map]}
@errors {400, 401, 402, 403, 404, 429, 500}

@endpoint PATCH /v2/sandboxes/{name}
@required {name: str}
@optional {projectId: str, teamId: str, slug: str, resources: map{vcpus: int, memory: int}, runtime: str(node22/node24/python3.13), timeout: int, persistent: bool, snapshotExpiration: any, networkPolicy: map{mode!: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, env: map, tags: map}
@returns(200) {sandbox: map{name: str, currentSnapshotId: str, currentSessionId: str, status: str, statusUpdatedAt: num, persistent: bool, region: str, vcpus: num, memory: num, runtime: str, timeout: num, snapshotExpiration: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, totalEgressBytes: num, totalIngressBytes: num, totalActiveCpuDurationMs: num, totalDurationMs: num, cwd: str, tags: map, createdAt: num, updatedAt: num}}
@errors {400, 401, 402, 403, 404, 410, 422, 500}

@endpoint DELETE /v2/sandboxes/{name}
@required {name: str}
@optional {projectId: str, teamId: str, slug: str}
@returns(200) {sandbox: map{name: str, currentSnapshotId: str, currentSessionId: str, status: str, statusUpdatedAt: num, persistent: bool, region: str, vcpus: num, memory: num, runtime: str, timeout: num, snapshotExpiration: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}, totalEgressBytes: num, totalIngressBytes: num, totalActiveCpuDurationMs: num, totalDurationMs: num, cwd: str, tags: map, createdAt: num, updatedAt: num}}
@errors {400, 401, 403, 404, 410, 422}

@endpoint GET /v2/sandboxes/sessions/{sessionId}/cmd
@required {sessionId: str}
@optional {teamId: str, slug: str}
@returns(200) {commands: [map]}
@errors {400, 401, 403}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/cmd
@required {sessionId: str, command: str}
@optional {teamId: str, slug: str, args: [str], cwd: str, env: map=[object Object], sudo: bool=false, wait: bool=false}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sessionId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 410, 422}

@endpoint GET /v2/sandboxes/sessions/{sessionId}/cmd/{cmdId}
@required {sessionId: str, cmdId: str}
@optional {wait: str(true/false)=false, teamId: str, slug: str}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sessionId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 410, 422}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/cmd/{cmdId}/kill
@required {cmdId: str, sessionId: str, signal: num}
@optional {teamId: str, slug: str}
@returns(200) {command: map{id: str, name: str, args: [str], cwd: str, sessionId: str, exitCode: num?, startedAt: num}}
@errors {400, 401, 403, 404, 410, 422}

@endpoint GET /v2/sandboxes/sessions/{sessionId}/cmd/{cmdId}/logs
@required {sessionId: str, cmdId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/stop
@required {sessionId: str}
@optional {teamId: str, slug: str}
@returns(200) {session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 403, 410, 422, 500}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/extend-timeout
@required {sessionId: str, duration: num}
@optional {teamId: str, slug: str}
@returns(200) {session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 403, 410, 422, 500}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/network-policy
@required {sessionId: str, mode: str(allow-all/deny-all/custom/default-allow/default-deny)}
@optional {teamId: str, slug: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str]}
@returns(200) {session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 402, 403, 410, 422, 500}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/fs/read
@required {sessionId: str, path: str}
@optional {teamId: str, slug: str, cwd: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 422}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/fs/mkdir
@required {sessionId: str, path: str}
@optional {teamId: str, slug: str, cwd: str, recursive: bool=true}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/fs/write
@required {sessionId: str}
@optional {x-cwd: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 410, 422}

@endpoint POST /v2/sandboxes/sessions/{sessionId}/snapshot
@required {sessionId: str}
@optional {teamId: str, slug: str, expiration: any}
@returns(201) {snapshot: map{id: str, sourceSessionId: str, region: str, status: str, sizeBytes: num, expiresAt: num, createdAt: num, updatedAt: num}, session: map{sourceSandboxName: str, projectId: str, id: str, memory: num, vcpus: num, region: str, runtime: str, timeout: num, status: str, requestedAt: num, startedAt: num, cwd: str, requestedStopAt: num, stoppedAt: num, abortedAt: num, duration: num, sourceSnapshotId: str, snapshottedAt: num, createdAt: num, updatedAt: num, networkPolicy: map{mode: str, allowedDomains: [str], allowedCIDRs: [str], deniedCIDRs: [str], injectionRules: [map]}, activeCpuDurationMs: num, networkTransfer: map{ingress: num, egress: num}}}
@errors {400, 401, 402, 403, 410, 422, 500}

@endgroup

@group security
@endpoint POST /v1/security/attack-mode
@optional {teamId: str, slug: str}
@returns(200) {attackModeEnabled: bool, attackModeUpdatedAt: num}
@errors {400, 401, 403, 404}

@endpoint PUT /v1/security/firewall/config
@required {projectId: str, firewallEnabled: bool}
@optional {teamId: str, slug: str, managedRules: map, crs: map{sd: map, ma: map, lfi: map, rfi: map, rce: map, php: map, gen: map, xss: map, sqli: map, sf: map, java: map}, rules: [map{id: str, name!: str, description: str, active!: bool, conditionGroup!: [map], action!: map, valid: bool, validationErrors: any}], ips: [map{id: str, hostname!: str, ip!: str, notes: str, action!: str}], botIdEnabled: bool, logHeaders: any}
@returns(200) {active: map{ownerId: str, projectKey: str, id: str, version: num, updatedAt: str, firewallEnabled: bool, crs: map{sd: map{active: bool, action: str}, ma: map{active: bool, action: str}, lfi: map{active: bool, action: str}, rfi: map{active: bool, action: str}, rce: map{active: bool, action: str}, php: map{active: bool, action: str}, gen: map{active: bool, action: str}, xss: map{active: bool, action: str}, sqli: map{active: bool, action: str}, sf: map{active: bool, action: str}, java: map{active: bool, action: str}}, rules: [any], ips: [map], changes: [map], managedRules: map{bot_protection: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, ai_bots: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, owasp: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, vercel_ruleset: map{active: bool, action: str, updatedAt: str, userId: str, username: str}}, botIdEnabled: bool, logHeaders: any}}
@errors {400, 401, 402, 403, 404, 500}

@endpoint PATCH /v1/security/firewall/config
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 500}

@endpoint GET /v1/security/firewall/config/{configVersion}
@required {projectId: str, configVersion: str}
@optional {teamId: str, slug: str}
@returns(200) {ownerId: str, projectKey: str, id: str, version: num, updatedAt: str, firewallEnabled: bool, crs: map{sd: map{active: bool, action: str}, ma: map{active: bool, action: str}, lfi: map{active: bool, action: str}, rfi: map{active: bool, action: str}, rce: map{active: bool, action: str}, php: map{active: bool, action: str}, gen: map{active: bool, action: str}, xss: map{active: bool, action: str}, sqli: map{active: bool, action: str}, sf: map{active: bool, action: str}, java: map{active: bool, action: str}}, rules: [any], ips: [map], changes: [map], managedRules: map{bot_protection: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, ai_bots: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, owasp: map{active: bool, action: str, updatedAt: str, userId: str, username: str}, vercel_ruleset: map{active: bool, action: str, updatedAt: str, userId: str, username: str}}, botIdEnabled: bool, logHeaders: any}
@errors {400, 401, 403, 404}

@endpoint GET /v1/security/firewall/attack-status
@required {projectId: str}
@optional {since: num, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v1/security/firewall/bypass
@required {projectId: str}
@optional {limit: num, sourceIp: str, domain: str, projectScope: bool, offset: str, teamId: str, slug: str}
@returns(200) {result: [map], pagination: map{OwnerId: str, Id: str}}
@errors {400, 401, 403, 404, 500}

@endpoint POST /v1/security/firewall/bypass
@required {projectId: str}
@optional {teamId: str, slug: str, domain: str, projectScope: bool, sourceIp: str, allSources: bool, ttl: num, note: str}
@returns(200)
@errors {400, 401, 403, 404, 500}

@endpoint DELETE /v1/security/firewall/bypass
@required {projectId: str}
@optional {teamId: str, slug: str, domain: str, projectScope: bool, sourceIp: str, allSources: bool, note: str}
@returns(200) {ok: bool}
@errors {400, 401, 403, 404, 500}

@endpoint GET /v1/security/firewall/events
@required {projectId: str}
@optional {startTimestamp: num, endTimestamp: num, hosts: str}
@returns(200) {actions: [map]}
@errors {400, 401, 403, 404, 500}

@endgroup

@group storage
@endpoint POST /v1/storage/stores/integration/direct
@required {name: str, integrationConfigurationId: str, integrationProductIdOrSlug: str}
@optional {teamId: str, slug: str, metadata: map, externalId: str, protocolSettings: map, source: str(marketplace/deploy-button/external/v0/resource-claims/cli/oauth/backoffice)=marketplace, billingPlanId: str, paymentMethodId: str, prepaymentAmountCents: num}
@returns(200) {store: map?{projectsMetadata: [map], projectFilter: map{git: map{providers: any, owners: [str], repos: [str]}}, totalConnectedProjects: num, usageQuotaExceeded: bool, status: str?, ownership: str, capabilities: map{mcp: bool, mcpReadonly: bool, sso: bool, billable: bool, transferable: bool, secretsSync: bool, secretRotation: any, projects: bool, v0: bool}, metadata: map, externalResourceId: str, externalResourceStatus: str?, directPartnerConsoleUrl: str, product: map{id: str, name: str, slug: str, iconUrl: str, capabilities: map{mcp: bool, mcpReadonly: bool, sso: bool, billable: bool, transferable: bool, secretsSync: bool, secretRotation: any, sandbox: bool, linking: bool, projects: bool, v0: bool, importResource: bool, connectedImportResource: bool, nativeImportResource: bool, databaseUI: bool}, shortDescription: str, metadataSchema: map{type: str, properties: map, required: [str]}, resourceLinks: [map], tags: [str], projectConnectionScopes: [str], showSSOLinkOnProjectConnection: bool, disableResourceRenaming: bool, resourceTitle: str, agentSkillUrl: str, repl: map{enabled: bool, supportsReadOnlyMode: bool, welcomeMessage: str}, guides: [map], integration: map{id: str, name: str, slug: str, supportsInstallationBillingPlans: bool, icon: str, flags: [str]}, integrationConfigurationId: str, supportedProtocols: [str], primaryProtocol: str, logDrainStatus: str}, protocolSettings: map{experimentation: map{edgeConfigSyncingEnabled: bool, edgeConfigId: str, edgeConfigTokenId: str}}, notification: map{title: str, level: str, message: str, href: str}, secrets: [map], billingPlan: map{type: str, description: str, id: str, name: str, scope: str, paymentMethodRequired: bool, preauthorizationAmount: num, initialCharge: str, minimumAmount: str, maximumAmount: str, maximumAmountAutoPurchasePerPeriod: str, cost: str, details: [map], highlightedDetails: [map], quote: [map], effectiveDate: str, disabled: bool}, secretRotationRequestedAt: num, secretRotationRequestedReason: str, secretRotationRequestedBy: str, secretRotationCompletedAt: num, parentId: str, targets: [str]}}
@errors {400, 401, 402, 403, 404, 409, 429, 500}

@endgroup

@group teams
@endpoint GET /v3/teams/{teamId}/members
@required {teamId: str}
@optional {limit: num, since: num, until: num, search: str, role: str(OWNER/MEMBER/DEVELOPER/SECURITY/BILLING/VIEWER/VIEWER_FOR_PLUS/CONTRIBUTOR), excludeProject: str, eligibleMembersForProjectId: str, slug: str}
@returns(200) {members: [map], emailInviteCodes: [map], pagination: map{hasNext: bool, count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404}

@endpoint POST /v2/teams/{teamId}/members
@required {teamId: str}
@optional {slug: str}
@returns(200) {uid: str, username: str, email: str, role: str, teamRoles: [str], teamPermissions: [str]}
@errors {400, 401, 403, 503}

@endpoint POST /v1/teams/{teamId}/request
@required {teamId: str, joinedFrom: map{origin!: str, commitId: str, repoId: str, repoPath: str, gitUserId: any, gitUserLogin: str}}
@returns(200) {teamSlug: str, teamName: str, confirmed: bool, joinedFrom: map{origin: str, commitId: str, repoId: str, repoPath: str, gitUserId: any, gitUserLogin: str, ssoUserId: str, ssoConnectedAt: num, idpUserId: str, dsyncUserId: str, dsyncConnectedAt: num}, accessRequestedAt: num, github: map?{login: str}, gitlab: map?{login: str}, bitbucket: map?{login: str}}
@errors {400, 401, 403, 404, 429, 503}

@endpoint GET /v1/teams/{teamId}/request/{userId}
@required {userId: str, teamId: str}
@returns(200) {teamSlug: str, teamName: str, confirmed: bool, joinedFrom: map{origin: str, commitId: str, repoId: str, repoPath: str, gitUserId: any, gitUserLogin: str, ssoUserId: str, ssoConnectedAt: num, idpUserId: str, dsyncUserId: str, dsyncConnectedAt: num}, accessRequestedAt: num, github: map?{login: str}, gitlab: map?{login: str}, bitbucket: map?{login: str}}
@errors {400, 401, 403, 404}

@endpoint POST /v1/teams/{teamId}/members/teams/join
@required {teamId: str}
@optional {inviteCode: str}
@returns(200) {teamId: str, slug: str, name: str, from: str}
@errors {400, 401, 402, 403, 404}

@endpoint PATCH /v1/teams/{teamId}/members/{uid}
@required {uid: str, teamId: str}
@optional {confirmed: bool, role: str=MEMBER, projects: [map{projectId!: str, role!: str}], joinedFrom: map{ssoUserId: any}}
@returns(200) {id: str}
@errors {400, 401, 402, 403, 404, 409, 500}

@endpoint DELETE /v1/teams/{teamId}/members/{uid}
@required {uid: str, teamId: str}
@optional {newDefaultTeamId: str}
@returns(200) {id: str}
@errors {400, 401, 403, 404, 503}

@endpoint GET /v2/teams/{teamId}
@required {teamId: str}
@optional {slug: str}
@returns(200) {connect: map{enabled: bool}, creatorId: str, updatedAt: num, emailDomain: str?, saml: map{connection: map{type: str, status: str, state: str, connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, syncState: str}, directory: map{type: str, state: str, connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, syncState: str}, enforced: bool, defaultRedirectUri: str, roles: map}, inviteCode: str, description: str?, defaultRoles: map{teamRoles: [str], teamPermissions: [str]}, stagingPrefix: str, resourceConfig: map{concurrentBuilds: num, elasticConcurrencyEnabled: bool, edgeConfigSize: num, edgeConfigs: num, kvDatabases: num, blobStores: num, postgresDatabases: num, buildEntitlements: map{enhancedBuilds: bool}, buildMachine: map{default: str}}, previewDeploymentSuffix: str?, platform: bool, disableHardAutoBlocks: any, remoteCaching: map{enabled: bool}, defaultDeploymentProtection: map{passwordProtection: map?{deploymentType: str}, ssoProtection: map?{deploymentType: str}}, defaultExpirationSettings: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, enablePreviewFeedback: str?, enableProductionFeedback: str?, sensitiveEnvironmentVariablePolicy: str?, hideIpAddresses: bool?, hideIpAddressesInLogDrains: bool?, ipBuckets: [map], strictDeploymentProtectionSettings: map{enabled: bool, updatedAt: num}, nsnbConfig: map{preference: str}, id: str, slug: str, name: str?, avatar: str?, membership: map{uid: str, entitlements: [map], teamId: str, confirmed: bool, accessRequestedAt: num, role: str, teamRoles: [str], teamPermissions: [str], createdAt: num, created: num, joinedFrom: map{origin: str, commitId: str, repoId: str, repoPath: str, gitUserId: any, gitUserLogin: str, ssoUserId: str, ssoConnectedAt: num, idpUserId: str, dsyncUserId: str, dsyncConnectedAt: num}}, createdAt: num}
@errors {400, 401, 403, 404}

@endpoint PATCH /v2/teams/{teamId}
@required {teamId: str}
@optional {slug: str, avatar: str(regex), description: str, emailDomain: str(regex), name: str, previewDeploymentSuffix: str(hostname), regenerateInviteCode: bool, saml: map{enforced: bool, roles: map}, slug: str, enablePreviewFeedback: str, enableProductionFeedback: str, sensitiveEnvironmentVariablePolicy: str, remoteCaching: map{enabled: bool}, hideIpAddresses: bool, hideIpAddressesInLogDrains: bool, defaultDeploymentProtection: map{passwordProtection: map, ssoProtection: map}, defaultExpirationSettings: map{expiration: str, expirationProduction: str, expirationCanceled: str, expirationErrored: str}, strictDeploymentProtectionSettings: map{enabled!: bool}, nsnbConfig: any, resourceConfig: map{buildMachine: map}}
@returns(200) {connect: map{enabled: bool}, creatorId: str, updatedAt: num, emailDomain: str?, saml: map{connection: map{type: str, status: str, state: str, connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, syncState: str}, directory: map{type: str, state: str, connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, syncState: str}, enforced: bool, defaultRedirectUri: str, roles: map}, inviteCode: str, description: str?, defaultRoles: map{teamRoles: [str], teamPermissions: [str]}, stagingPrefix: str, resourceConfig: map{concurrentBuilds: num, elasticConcurrencyEnabled: bool, edgeConfigSize: num, edgeConfigs: num, kvDatabases: num, blobStores: num, postgresDatabases: num, buildEntitlements: map{enhancedBuilds: bool}, buildMachine: map{default: str}}, previewDeploymentSuffix: str?, platform: bool, disableHardAutoBlocks: any, remoteCaching: map{enabled: bool}, defaultDeploymentProtection: map{passwordProtection: map?{deploymentType: str}, ssoProtection: map?{deploymentType: str}}, defaultExpirationSettings: map{expirationDays: num, expirationDaysProduction: num, expirationDaysCanceled: num, expirationDaysErrored: num, deploymentsToKeep: num}, enablePreviewFeedback: str?, enableProductionFeedback: str?, sensitiveEnvironmentVariablePolicy: str?, hideIpAddresses: bool?, hideIpAddressesInLogDrains: bool?, ipBuckets: [map], strictDeploymentProtectionSettings: map{enabled: bool, updatedAt: num}, nsnbConfig: map{preference: str}, id: str, slug: str, name: str?, avatar: str?, membership: map{uid: str, entitlements: [map], teamId: str, confirmed: bool, accessRequestedAt: num, role: str, teamRoles: [str], teamPermissions: [str], createdAt: num, created: num, joinedFrom: map{origin: str, commitId: str, repoId: str, repoPath: str, gitUserId: any, gitUserLogin: str, ssoUserId: str, ssoConnectedAt: num, idpUserId: str, dsyncUserId: str, dsyncConnectedAt: num}}, createdAt: num}
@errors {400, 401, 402, 403, 428}

@endpoint GET /v2/teams
@optional {limit: num, since: num, until: num}
@returns(200) {teams: [any], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403}

@endpoint POST /v1/teams
@required {slug: str}
@optional {name: str, attribution: map{sessionReferrer: str, landingPage: str, pageBeforeConversionPage: str, utm: map}}
@returns(200) {id: str, slug: str}
@errors {400, 401, 403}

@endpoint POST /v1/teams/{teamId}/dsync-roles
@required {teamId: str, roles: map}
@optional {slug: str}
@returns(200) {ok: bool}
@errors {400, 401, 403}

@endpoint DELETE /v1/teams/{teamId}
@required {teamId: str}
@optional {newDefaultTeamId: str, slug: str, reasons: [map{slug!: str, description!: str}]}
@returns(200) {id: str, newDefaultTeamIdError: bool}
@errors {400, 401, 402, 403, 409}

@endpoint DELETE /v1/teams/{teamId}/invites/{inviteId}
@required {inviteId: str, teamId: str}
@returns(200) {id: str}
@errors {400, 401, 403, 404}

@endpoint PATCH /v1/teams/{teamId}/microfrontends/{groupId}
@required {groupId: str, teamId: str}
@optional {slug: str, name: str, fallbackEnvironment: str}
@returns(200) {updatedMicrofrontendsGroup: map{name: str, slug: str, id: str, fallbackEnvironment: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v1/teams/{teamId}/microfrontends/{groupId}
@required {groupId: str, teamId: str}
@optional {slug: str}
@returns(200)
@errors {400, 401, 403, 404, 500}

@endgroup

@group files
@endpoint POST /v2/files
@optional {Content-Length: num, x-vercel-digest: str, x-now-digest: str, x-now-size: num, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endgroup

@group user
@endpoint GET /v6/user/tokens
@returns(200)
@errors {400, 401, 403}

@endpoint POST /v3/user/tokens
@required {name: str}
@optional {teamId: str, slug: str, expiresAt: num}
@returns(200) {token: map{id: str, name: str, type: str, prefix: str, suffix: str, origin: str, scopes: [any], createdAt: num, activeAt: num, expiresAt: num, revokedAt: num, leakedAt: num, leakedUrl: str}, bearerToken: str}
@errors {400, 401, 403, 404}

@endpoint GET /v5/user/tokens/{tokenId}
@required {tokenId: str}
@returns(200) {token: map{id: str, name: str, type: str, prefix: str, suffix: str, origin: str, scopes: [any], createdAt: num, activeAt: num, expiresAt: num, revokedAt: num, leakedAt: num, leakedUrl: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v3/user/tokens/{tokenId}
@required {tokenId: str}
@returns(200) {tokenId: str}
@errors {400, 401, 403, 404}

@endpoint GET /v2/user
@returns(200) {user: any}
@errors {302, 400, 401, 403, 409}

@endpoint DELETE /v1/user
@optional {reasons: [map{slug!: str, description!: str}]}
@returns(202) {id: str, email: str, message: str}
@errors {400, 401, 402, 403}

@endgroup

@group webhooks
@endpoint POST /v1/webhooks
@required {url: str(uri), events: [str]}
@optional {teamId: str, slug: str, projectIds: [str]}
@returns(200) {secret: str, events: [str], id: str, url: str, ownerId: str, createdAt: num, updatedAt: num, projectIds: [str]}
@errors {400, 401, 403}

@endpoint GET /v1/webhooks
@optional {projectId: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /v1/webhooks/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {events: [str], id: str, url: str, ownerId: str, createdAt: num, updatedAt: num, projectIds: [str]}
@errors {400, 401, 403}

@endpoint DELETE /v1/webhooks/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403}

@endgroup

@group deployments
@endpoint GET /v2/deployments/{id}/aliases
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {aliases: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /v2/deployments/{id}/aliases
@required {id: any}
@optional {teamId: str, slug: str, alias: str, redirect: str}
@returns(200) {uid: str, alias: str, created: str(date-time), oldDeploymentId: str?}
@errors {400, 401, 402, 403, 404, 409}

@endgroup

@group aliases
@endpoint GET /v4/aliases
@optional {domain: any, from: num, limit: num, projectId: str, since: num, until: num, rollbackDeploymentId: str, teamId: str, slug: str}
@returns(200) {aliases: [map], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404}

@endpoint GET /v4/aliases/{idOrAlias}
@required {idOrAlias: str}
@optional {from: num, projectId: str, since: num, until: num, teamId: str, slug: str}
@returns(200) {alias: str, created: str(date-time), createdAt: num?, creator: map{uid: str, email: str, username: str}, deletedAt: num?, deployment: map{id: str, url: str, meta: str}, deploymentId: str?, projectId: str?, redirect: str?, redirectStatusCode: num?, uid: str, updatedAt: num?, protectionBypass: map, microfrontends: map{defaultApp: map{projectId: str}, applications: any}}
@errors {400, 401, 403, 404}

@endpoint DELETE /v2/aliases/{aliasId}
@required {aliasId: any}
@optional {teamId: str, slug: str}
@returns(200) {status: str}
@errors {400, 401, 403, 404}

@endpoint PATCH /aliases/{id}/protection-bypass
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 409, 428}

@endgroup

@group certs
@endpoint GET /v8/certs/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {id: str, createdAt: num, expiresAt: num, autoRenew: bool, cns: [str]}
@errors {400, 401, 403, 404}

@endpoint DELETE /v8/certs/{id}
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /v8/certs
@optional {teamId: str, slug: str, cns: [str]}
@returns(200) {id: str, createdAt: num, expiresAt: num, autoRenew: bool, cns: [str]}
@errors {400, 401, 402, 403, 404, 449, 500}

@endpoint PUT /v8/certs
@required {ca: str, key: str, cert: str}
@optional {teamId: str, slug: str, skipValidation: bool}
@returns(200) {id: str, createdAt: num, expiresAt: num, autoRenew: bool, cns: [str]}
@errors {400, 401, 402, 403}

@endgroup

@group deployments
@endpoint GET /v6/deployments/{id}/files
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /v8/deployments/{id}/files/{fileId}
@required {id: str, fileId: str}
@optional {path: str, teamId: str, slug: str}
@errors {400, 401, 403, 404, 410}

@endpoint GET /v6/deployments
@optional {app: str, from: num, limit: num, projectId: str, projectIds: [str], target: str, to: num, users: str, since: num, until: num, state: str, rollbackCandidate: bool, branch: str, sha: str, teamId: str, slug: str}
@returns(200) {pagination: map{count: num, next: num?, prev: num?}, deployments: [map]}
@errors {400, 401, 403, 404, 422}

@endpoint DELETE /v13/deployments/{id}
@required {id: str}
@optional {url: str, teamId: str, slug: str}
@returns(200) {uid: str, state: str}
@errors {400, 401, 403, 404}

@endgroup

@end
