@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 419
@hint download_for_search
@toc access-groups(11), ai-gateway(12), artifacts(7), billing(3), bulk-redirects(7), projects(81), deployments(21), connect(18), networking(5), domains(15), registrar(19), log-drains(4), drains(6), edge-cache(4), global-config(18), env(6), events(2), teams(19), integrations(12), installations(25), api-keys(1), kms(13), microfrontends(5), observability(5), sandboxes(30), security(13), speed-insights(1), storage(4), files(1), user(6), vcr(13), v2(1), {teamSlug}(13), web(1), query(4), webhooks(4), aliases(4), certs(5)

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

@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) {accessGroupId: str, createdAt: str, entitlements: [str], membersCount: num, name: str, projectsCount: num, teamId: str, teamPermissions: [str], teamRoles: [str], updatedAt: str}
@errors {400, 401, 403, 410}

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

@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, 410}

@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, 410}

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

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

@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) {accessGroupId: str, createdAt: str, projectId: str, role: str, teamId: str, updatedAt: str}
@errors {400, 401, 403, 410}

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

@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) {accessGroupId: str, createdAt: str, projectId: str, role: str, teamId: str, updatedAt: str}
@errors {400, 401, 403, 410}

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

@endgroup

@group ai-gateway
@endpoint POST /v1/ai-gateway/virtual-model-configs
@optional {teamId: str, slug: str}
@returns(201) {allowFallbackFromFast: bool, baseUrl: str, byokCredentialIds: [str], caching: str, createdAt: num, createdBy: str, deleted: bool, description: str, disallowPromptTraining: bool, displayName: str, has: [str], hipaaCompliant: bool, inferenceRegion: map{geoRegion: str, providerRegion: str, providers: map, scope: str}, instanceId: str, kind: str, models: [str], modelSlug: str, observabilityTags: [str], ownerId: str, providerOnly: [str], providerOptions: map, providerOrder: [str], providerTimeouts: map{byok: map}, selector: str, serviceTier: str, sort: str, speed: str, status: str, updatedAt: num, updatedBy: str, virtualModelSlug: str, visibility: str, zeroDataRetention: bool}
@errors {400, 401, 403, 409, 410, 429, 500}

@endpoint GET /v1/ai-gateway/virtual-model-configs
@optional {ownerId: str, virtualModelSlug: str, limit: int, cursor: str, teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 500}

@endpoint PATCH /v1/ai-gateway/virtual-model-configs
@optional {teamId: str, slug: str}
@returns(200) {allowFallbackFromFast: bool, baseUrl: str, byokCredentialIds: [str], caching: str, createdAt: num, createdBy: str, deleted: bool, description: str, disallowPromptTraining: bool, displayName: str, has: [str], hipaaCompliant: bool, inferenceRegion: map{geoRegion: str, providerRegion: str, providers: map, scope: str}, instanceId: str, kind: str, models: [str], modelSlug: str, observabilityTags: [str], ownerId: str, providerOnly: [str], providerOptions: map, providerOrder: [str], providerTimeouts: map{byok: map}, selector: str, serviceTier: str, sort: str, speed: str, status: str, updatedAt: num, updatedBy: str, virtualModelSlug: str, visibility: str, zeroDataRetention: bool}
@errors {400, 401, 403, 404, 410, 429, 500}

@endpoint DELETE /v1/ai-gateway/virtual-model-configs
@required {virtualModelSlug: str}
@optional {ownerId: str, updatedBy: str, actingIp: str, actingUserAgent: str, teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410, 500}

@endpoint GET /v1/ai-gateway/virtual-model-configs/list
@optional {ownerId: str, limit: int, cursor: str, teamId: str, slug: str}
@returns(200) {cursor: str?, virtualModelConfigs: [map]}
@errors {400, 401, 403, 410, 500}

@endpoint GET /v1/ai-gateway/virtual-model-configs/{vmcSlug}
@required {vmcSlug: str}
@optional {ownerId: str, teamId: str, slug: str}
@returns(200) {allowFallbackFromFast: bool, baseUrl: str, byokCredentialIds: [str], caching: str, createdAt: num, createdBy: str, deleted: bool, description: str, disallowPromptTraining: bool, displayName: str, has: [str], hipaaCompliant: bool, inferenceRegion: map{geoRegion: str, providerRegion: str, providers: map, scope: str}, instanceId: str, kind: str, models: [str], modelSlug: str, observabilityTags: [str], ownerId: str, providerOnly: [str], providerOptions: map, providerOrder: [str], providerTimeouts: map{byok: map}, selector: str, serviceTier: str, sort: str, speed: str, status: str, updatedAt: num, updatedBy: str, virtualModelSlug: str, visibility: str, zeroDataRetention: bool}
@errors {400, 401, 403, 404, 410, 500}

@endpoint PATCH /v1/ai-gateway/virtual-model-configs/{vmcSlug}
@required {vmcSlug: str}
@optional {teamId: str, slug: str}
@returns(200) {allowFallbackFromFast: bool, baseUrl: str, byokCredentialIds: [str], caching: str, createdAt: num, createdBy: str, deleted: bool, description: str, disallowPromptTraining: bool, displayName: str, has: [str], hipaaCompliant: bool, inferenceRegion: map{geoRegion: str, providerRegion: str, providers: map, scope: str}, instanceId: str, kind: str, models: [str], modelSlug: str, observabilityTags: [str], ownerId: str, providerOnly: [str], providerOptions: map, providerOrder: [str], providerTimeouts: map{byok: map}, selector: str, serviceTier: str, sort: str, speed: str, status: str, updatedAt: num, updatedBy: str, virtualModelSlug: str, visibility: str, zeroDataRetention: bool}
@errors {400, 401, 403, 404, 410, 429, 500}

@endpoint DELETE /v1/ai-gateway/virtual-model-configs/{vmcSlug}
@required {vmcSlug: str}
@optional {ownerId: str, updatedBy: str, actingIp: str, actingUserAgent: str, teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410, 500}

@endpoint POST /v1/ai-gateway/rules
@optional {teamId: str, slug: str}
@returns(201) {action: map{reason: str, rewriteModel: str}, createdAt: num, createdBy: str, deleted: bool, description: str, enabled: bool, match: map{model: str}, ownerId: str, ruleId: str, type: str, updatedAt: num, updatedBy: str}
@errors {400, 401, 403, 409, 410, 500}

@endpoint GET /v1/ai-gateway/rules
@optional {includeDisabled: str(true/false), teamId: str, slug: str}
@returns(200) {rules: [map]}
@errors {400, 401, 403, 410, 500}

@endpoint PATCH /v1/ai-gateway/rules
@optional {teamId: str, slug: str}
@returns(200) {action: map{reason: str, rewriteModel: str}, createdAt: num, createdBy: str, deleted: bool, description: str, enabled: bool, match: map{model: str}, ownerId: str, ruleId: str, type: str, updatedAt: num, updatedBy: str}
@errors {400, 401, 403, 404, 410, 500}

@endpoint DELETE /v1/ai-gateway/rules
@required {ruleId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410, 500}

@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, 410}

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

@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, 410}

@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, 410}

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

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

@endpoint DELETE /v8/artifacts
@optional {teamId: str, slug: str}
@returns(200) {deletedCount: num}
@errors {400, 401, 403, 410}

@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, 410, 500, 503}

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

@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, 409, 410, 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{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, key: str, lastModified: num, name: str, redirectCount: num}}
@errors {400, 401, 403, 410, 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, 410}

@endpoint DELETE /v1/bulk-redirects
@required {projectId: str, redirects: [str]}
@optional {teamId: str, slug: str, name: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 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{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, key: str, lastModified: num, name: str, redirectCount: num}}
@errors {400, 401, 403, 404, 410, 500}

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

@endpoint GET /v1/bulk-redirects/versions
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {versions: [map]}
@errors {400, 401, 403, 410, 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{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, key: str, lastModified: num, name: str, redirectCount: num}}
@errors {400, 401, 403, 404, 410, 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, 410, 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) {blocks: str, createdAt: num, deletedAt: num, id: str, isRerequestable: bool, name: str, ownerId: str, projectId: str, requires: str, source: any, sourceIntegrationConfigurationId: str, sourceKind: str, targets: [str], timeout: num, updatedAt: num}
@errors {400, 401, 403, 410, 500}

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

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

@endgroup

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

@endpoint POST /v2/deployments/{deploymentId}/check-runs
@required {deploymentId: str, checkId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 500}

@endpoint GET /v2/deployments/{deploymentId}/check-runs/{checkRunId}
@required {deploymentId: str, checkRunId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 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)
@errors {400, 401, 403, 410, 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) {blocking: bool, completedAt: num, conclusion: str, createdAt: num, deploymentId: str, detailsUrl: str, externalId: str, id: str, integrationId: str, name: str, output: map{metrics: map{CLS: map{previousValue: num, source: str, value: num?}, FCP: map{previousValue: num, source: str, value: num?}, LCP: map{previousValue: num, source: str, value: num?}, TBT: map{previousValue: num, source: str, value: num?}, virtualExperienceScore: map{previousValue: num, source: str, value: num?}}}, path: str, rerequestable: bool, startedAt: num, status: str, updatedAt: num}
@errors {400, 401, 403, 404, 410}

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

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

@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) {blocking: bool, completedAt: num, conclusion: str, createdAt: num, deploymentId: str, detailsUrl: str, externalId: str, id: str, integrationId: str, name: str, output: map{metrics: map{CLS: map{previousValue: num, source: str, value: num?}, FCP: map{previousValue: num, source: str, value: num?}, LCP: map{previousValue: num, source: str, value: num?}, TBT: map{previousValue: num, source: str, value: num?}, virtualExperienceScore: map{previousValue: num, source: str, value: num?}}}, path: str, rerequestable: bool, startedAt: num, status: str, updatedAt: num}
@errors {400, 401, 403, 404, 410, 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, 410}

@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, 410}

@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, 410}

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

@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, 410}

@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, 410}

@endgroup

@group networking
@endpoint POST /v1/networking/privatelink/endpoints
@required {projectId: str, name: str, vercelRegion: str, awsServiceName: str}
@optional {teamId: str, slug: str, enablePrivateDns: bool}
@returns(201) {awsDnsEntries: [str], awsServiceName: str, createdAt: num, endpointId: str, name: str, privateDnsNames: [str], projectId: str, status: str, statusMessage: str, teamId: str, updatedAt: num, vercelRegion: str, vpcEndpointId: str}
@errors {400, 401, 403, 404, 409, 410}

@endpoint GET /v1/networking/privatelink/endpoints
@required {projectId: str}
@optional {teamId: str, slug: str}
@returns(200)
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/networking/privatelink/endpoints/{endpointId}
@required {projectId: str, endpointId: str}
@optional {teamId: str, slug: str}
@returns(200) {awsDnsEntries: [str], awsServiceName: str, createdAt: num, endpointId: str, name: str, privateDnsNames: [str], projectId: str, status: str, statusMessage: str, teamId: str, updatedAt: num, vercelRegion: str, vpcEndpointId: str}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/networking/privatelink/endpoints/{endpointId}
@required {projectId: str, endpointId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 410}

@endpoint PATCH /v1/networking/privatelink/endpoints/{endpointId}
@required {projectId: str, endpointId: str}
@optional {teamId: str, slug: str, name: str, enablePrivateDns: bool}
@returns(200) {awsDnsEntries: [str], awsServiceName: str, createdAt: num, endpointId: str, name: str, privateDnsNames: [str], projectId: str, status: str, statusMessage: str, teamId: str, updatedAt: num, vercelRegion: str, vpcEndpointId: str}
@errors {400, 401, 403, 404, 409, 410}

@endgroup

@group connect
@endpoint GET /v2/connect/connectors
@optional {limit: int, cursor: str, projectId: str, search: str, type: str, service: str, sort: str(name/createdAt/updatedAt), teamId: str, slug: str}
@returns(200) {connectors: [map], pagination: map{next: str?}}
@errors {400, 401, 403, 409, 410, 422}

@endpoint GET /v1/connect/connectors/{connector}
@required {connector: str}
@optional {teamId: str, slug: str}
@returns(200) {accentColor: str, appTokens: map{crossInstallation: bool, permissionsUrl: str, requiresReinstallation: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, backgroundColor: str, clientUrl: str?, connectionMethod: str, createdAt: num, createdBy: any, creationMode: str, defaultInstallationId: str, devsite: str, displayName: str, docsite: str, events: [str], icon: str, id: str, knownStale: bool, managed: map{sync: bool}, name: str, redirectUri: str, reinstallAt: num, service: str, supportedSubjectTypes: [str], supportsIcon: any, supportsInstallation: bool, supportsRevocation: bool, supportsTriggers: bool, target: str, triggerDestinations: [map], triggers: map{enabled: bool}, type: str, typeIcon: str, typeName: str, uid: str, updatedAt: num, updatedBy: any, userTokens: map{crossInstallation: bool, manualCredentialInput: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, website: str}
@errors {400, 401, 403, 404, 409, 410, 422}

@endpoint DELETE /v1/connect/connectors/{connector}
@required {connector: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 410, 422, 502}

@endpoint POST /v1/connect/connectors
@required {data: any}
@optional {teamId: str, slug: str, icon: str, backgroundColor: str, accentColor: str, type: str, service: str, connectionMethod: str, params: map, target: str, uid: str, name: str, projectId: str, environments: [any], triggers: bool, triggerType: str, triggerData: map, triggerDestination: any, events: [str]}
@returns(201) {accentColor: str, appTokens: map{crossInstallation: bool, permissionsUrl: str, requiresReinstallation: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, backgroundColor: str, clientUrl: str?, connectionMethod: str, createdAt: num, createdBy: any, creationMode: str, defaultInstallationId: str, devsite: str, displayName: str, docsite: str, events: [str], icon: str, id: str, knownStale: bool, managed: map{sync: bool}, name: str, redirectUri: str, reinstallAt: num, service: str, supportedSubjectTypes: [str], supportsIcon: any, supportsInstallation: bool, supportsRevocation: bool, supportsTriggers: bool, target: str, triggerDestinations: [map], triggers: map{enabled: bool}, type: str, typeIcon: str, typeName: str, uid: str, updatedAt: num, updatedBy: any, userTokens: map{crossInstallation: bool, manualCredentialInput: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, website: str}
@errors {400, 401, 403, 404, 409, 410, 422, 500, 502}

@endpoint PATCH /v2/connect/connectors/{connector}
@required {connector: str}
@optional {teamId: str, slug: str, triggers: bool, events: [str], data: any, icon: str, backgroundColor: str, accentColor: str, uid: str, name: str}
@returns(200) {connector: map{accentColor: str, appTokens: map{crossInstallation: bool, permissionsUrl: str, requiresReinstallation: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, backgroundColor: str, clientUrl: str?, connectionMethod: str, createdAt: num, createdBy: any, creationMode: str, defaultInstallationId: str, devsite: str, displayName: str, docsite: str, events: [str], icon: str, id: str, knownStale: bool, managed: map{sync: bool}, name: str, redirectUri: str, reinstallAt: num, service: str, supportedSubjectTypes: [str], supportsIcon: any, supportsInstallation: bool, supportsRevocation: bool, supportsTriggers: bool, target: str, triggerDestinations: [map], triggers: map{enabled: bool}, type: str, typeIcon: str, typeName: str, uid: str, updatedAt: num, updatedBy: any, userTokens: map{crossInstallation: bool, manualCredentialInput: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, website: str}, reconsentNeeded: map{scope: str}, reinstallNeeded: bool, serviceSync: map{errors: [map], status: str}}
@errors {400, 401, 403, 404, 409, 410, 422, 502}

@endpoint PATCH /v1/connect/connectors/{connector}/trigger-destinations
@required {connector: str, destinations: [any]}
@optional {teamId: str, slug: str}
@returns(200) {accentColor: str, appTokens: map{crossInstallation: bool, permissionsUrl: str, requiresReinstallation: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, backgroundColor: str, clientUrl: str?, connectionMethod: str, createdAt: num, createdBy: any, creationMode: str, defaultInstallationId: str, devsite: str, displayName: str, docsite: str, events: [str], icon: str, id: str, knownStale: bool, managed: map{sync: bool}, name: str, redirectUri: str, reinstallAt: num, service: str, supportedSubjectTypes: [str], supportsIcon: any, supportsInstallation: bool, supportsRevocation: bool, supportsTriggers: bool, target: str, triggerDestinations: [map], triggers: map{enabled: bool}, type: str, typeIcon: str, typeName: str, uid: str, updatedAt: num, updatedBy: any, userTokens: map{crossInstallation: bool, manualCredentialInput: bool, scopes: [str], supportedAuthorizationDetails: [str], supportsRefinement: bool, supportsResources: bool}, website: str}
@errors {400, 401, 403, 404, 409, 410, 422}

@endpoint GET /v2/connect/connectors/{connector}/projects
@required {connector: str}
@optional {limit: int, cursor: str, teamId: str, slug: str}
@returns(200) {pagination: map{next: str?}, projects: [map]}
@errors {400, 401, 403, 404, 409, 410, 422}

@endpoint GET /v1/connect/connectors/{connector}/projects/{projectId}
@required {connector: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(200) {connectorId: str, createdAt: num, enabledEnvironments: [any], project: map{customEnvironments: [map], id: str, name: str}, updatedAt: num}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/connect/connectors/{connector}/projects/{projectId}
@required {connector: str, projectId: str, environments: [any]}
@optional {teamId: str, slug: str}
@returns(200) {connectorId: str, createdAt: num, enabledEnvironments: [any], project: map{customEnvironments: [map], id: str, name: str}, updatedAt: num}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/connect/connectors/{connector}/projects/{projectId}
@required {connector: str, projectId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410}

@endpoint GET /v2/connect/projects/{projectId}/connectors
@required {projectId: str}
@optional {limit: int, cursor: str, teamId: str, slug: str}
@returns(200) {connectors: [map], pagination: map{next: str?}}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/connect/token/{connector}
@required {connector: str}
@optional {subject: any, installationId: str, audience: [str], scopes: [str], resources: [str], authorizationDetails: [map{type: str}], validityBufferMs: num}
@returns(200) {authorizationId: str, claims: map, connector: map{id: str, type: str, uid: str}, expiresAt: num, externalSubject: str, installationId: str, metadata: map, name: str, tenantId: str, token: str, tokenGroupId: str, tokenId: str}
@errors {400, 401, 403, 404, 410, 422, 429, 501}

@endpoint POST /v1/connect/authorize/{connector}
@required {connector: str}
@optional {subject: any, installationId: str, audience: [str], scopes: [str], resources: [str], authorizationDetails: [map{type: str}], validityBufferMs: num, returnUrl: str, webhook: str, prompt: str, deviceCode: bool, expiresInMs: num, additionalParams: map}
@returns(200) {connector: map{displayName: str, id: str, name: str, service: str, serviceName: str, type: str, uid: str}, deviceCode: str, expiresAt: num, request: str, url: str, verifier: str}
@errors {400, 401, 403, 404, 410, 501}

@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, 410, 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, 410}

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

@endpoint POST /v13/deployments
@required {name: str}
@optional {forceNew: any(0/1), skipAutoDetectionConfirmation: any(0/1), teamId: str, slug: str, buildMachine: str, customEnvironmentSlugOrId: str, deploymentId: str, files: [any], gitAccessToken: str, gitMetadata: map{remoteUrl: str, commitAuthorName: str, commitAuthorEmail: str, commitMessage: str, commitRef: str, commitSha: str, dirty: bool, ci: bool, ciType: str, ciGitProviderUsername: str, ciGitRepoVisibility: str, rootDirectory: 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)
@errors {400, 401, 402, 403, 404, 409, 410, 426, 429, 500, 503}

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

@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, 410}

@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, 410}

@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) {comment: str, createdAt: num?, creator: str, domain: str, id: str, name: str, recordType: str, ttl: num, type: str, value: str}
@errors {400, 401, 402, 403, 404, 409, 410}

@endpoint PUT /domains/{domain}/records
@required {domain: str}
@returns(200) {recordIds: [str]}
@errors {400, 401, 403, 404, 409, 410, 415}

@endpoint GET /domains/records/{recordId}
@required {recordId: str}
@returns(200) {comment: str, createdAt: num?, creator: str, domain: str, id: str, name: str, recordType: str, ttl: num, type: str, value: str}
@errors {400, 401, 403, 404, 410}

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

@endgroup

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

@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/price
@required {domains: [str]}
@optional {teamId: str, years: num}
@returns(200) {results: [map]}
@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}/contact-info/schema
@required {domain: str}
@optional {teamId: str}
@returns(200)
@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-verification
@required {domain: str}
@optional {teamId: str}
@returns(200)
@errors {400, 401, 403, 404, 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) {acceptedChallenges: [str], configuredBy: str?, recommendedCNAME: [map], recommendedIPv4: [map], misconfigured: bool}
@errors {400, 401, 403, 410}

@endpoint GET /v9/domains/{domain}/verification
@required {domain: str}
@optional {teamId: str, slug: str}
@returns(200) {txtRecord: str, verificationDomain: str}
@errors {400, 401, 403, 404, 410}

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

@endpoint GET /v1/domains/{domain}/project-domains
@required {domain: str}
@optional {limit: num, since: num, until: num, teamId: str, slug: str}
@returns(200) {pagination: map{count: num, next: num?, prev: num?}, projectDomains: [map]}
@errors {400, 401, 403, 404, 410}

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

@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, 410}

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

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

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

@endgroup

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

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

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

@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, 410}

@endgroup

@group drains
@endpoint POST /v1/drains
@required {name: str, projects: str(some/all), schemas: map}
@optional {teamId: str, slug: str, projectIds: [str], filter: map{version!: 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, 402, 403, 410}

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

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

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

@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, 402, 403, 404, 410}

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

@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, 410}

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

@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, 410}

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

@endgroup

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@endpoint POST /v1/global-config/{edgeConfigId}/backups/{edgeConfigBackupVersionId}/restore
@required {edgeConfigId: str, edgeConfigBackupVersionId: str}
@optional {teamId: str, slug: str}
@returns(200) {digest: str, previousDigest: str, restoredFrom: str, status: str}
@errors {400, 401, 402, 403, 404, 409, 410, 412}

@endpoint GET /v1/global-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, 410}

@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, 410}

@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, 410}

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

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

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

@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, 410}

@endgroup

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

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

@endgroup

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

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

@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), maintainerIds: [str], permanent: bool, tags: [str]}
@returns(201) {createdAt: num, createdBy: str, description: str, environments: map, id: str, kind: str, maintainerIds: [str], ownerId: str, permanent: bool, projectId: str, revision: num, seed: num, slug: str, state: str, tags: [str], typeName: str, updatedAt: num, updatedBy: str, variants: [map]}
@errors {400, 401, 402, 403, 404, 409, 410}

@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) {createdAt: num, createdBy: str, description: str, environments: map, id: str, kind: str, maintainerIds: [str], ownerId: str, permanent: bool, projectId: str, revision: num, seed: num, slug: str, state: str, tags: [str], typeName: str, updatedAt: num, updatedBy: str, variants: [map], metadata: map{creator: map{id: str, name: str}}}
@errors {304, 400, 401, 402, 403, 404, 410}

@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), maintainerIds: [str], permanent: bool, tags: [str]}
@returns(200)
@errors {304, 400, 401, 402, 403, 404, 409, 410}

@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, 410}

@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) {pagination: map, versions: [map]}
@errors {304, 400, 401, 402, 403, 404, 410}

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

@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) {createdAt: num, enabled: bool, entities: [map], environments: [str], metadata: map{activeFlagCount: num, archivedFlagCount: num, configUpdatedAt: num, packRevision: num, packSizeInBytes: num, segmentCount: num}, ownerId: str, projectId: str, typeName: str, updatedAt: num}
@returns(201) {createdAt: num, enabled: bool, entities: [map], environments: [str], metadata: map{activeFlagCount: num, archivedFlagCount: num, configUpdatedAt: num, packRevision: num, packSizeInBytes: num, segmentCount: num}, ownerId: str, projectId: str, typeName: str, updatedAt: num}
@errors {400, 401, 402, 403, 404, 409, 410}

@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, 410}

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

@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), tags: [str], slug: str}
@returns(200) {data: [map], pagination: map{next: str?}}
@errors {400, 401, 403, 410}

@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) {createdAt: num, createdBy: str, data: map{exclude: map, include: map, rules: [map]}, description: str, hint: str, id: str, label: str, projectId: str, slug: str, typeName: str, updatedAt: num, usedByFlags: [str], usedBySegments: [str]}
@errors {400, 401, 402, 403, 404, 409, 410}

@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, 410}

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

@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 {304, 400, 401, 402, 403, 404, 409, 410}

@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, 410}

@endgroup

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

@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, 410}

@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) {createdAt: num, createdBy: str, deletedAt: num, environment: str, hashKey: str, label: str, partialKeyValue: str, projectId: str, type: str, updatedAt: num, keyValue: str, tokenValue: str}
@errors {400, 401, 402, 403, 404, 409, 410}

@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, 410}

@endgroup

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

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

@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/import-recommended-integrations/organization), teamId: str, slug: str}
@returns(200) {plans: [map]}
@errors {400, 401, 403, 404, 410}

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

@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, 410}

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

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

@endpoint POST /v1/installations/{integrationConfigurationId}/credentials/rotate
@required {integrationConfigurationId: str, client_secret: str}
@optional {client_id: str}
@returns(200) {access_token: str, expires_in: num, scope: str, token_type: str}
@errors {400, 401, 403, 404, 409, 410}

@endpoint POST /v1/installations/{integrationConfigurationId}/credentials/revoke
@required {integrationConfigurationId: str, token: str, client_secret: str}
@optional {client_id: str}
@returns(200) {already_revoked: bool, revoked: bool}
@errors {400, 401, 403, 404, 409, 410}

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

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

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

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

@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, 410, 422}

@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, 410, 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, 410}

@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, 410}

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

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

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

@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, 410}

@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, 410, 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, 410, 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, 410}

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

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

@endpoint GET /v1/integrations/configuration/{id}/products
@required {id: str}
@optional {teamId: str, slug: str}
@returns(200) {configuration: map{id: str}, integration: map{id: str, name: str, slug: str}, products: [map]}
@errors {400, 401, 403, 404, 410, 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, 410}

@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) {branch: str, clientId: str, configurationId: str, createdAt: num, createdFrom: str, deliveryFormat: str, environments: [str], headers: map, id: str, name: str, ownerId: str, projectId: str?, projectIds: [str], samplingRate: num, source: any, sources: [str], url: str}
@errors {400, 401, 403, 410}

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

@endgroup

@group api-keys
@endpoint POST /api-keys
@required {purpose: str}
@optional {projectId: str, name: str, expiresAt: num, aiGatewayQuota: map{limitAmount!: num, includeByokInQuota: bool, refreshPeriod: str, alertThresholds: [num]}, metadata: map}
@returns(200) {apiKeyString: str, apiKey: map{id: str, name: str, partialKey: str, teamId: str, purpose: str, projectId: str?, expiresAt: num?, activeAt: num, createdAt: num, createdBy: str, leakedAt: num?, leakedUrl: str?, createdByAppId: str?, quota: map{quotaEntityId: str, limitAmount: num, currentSpend: num, currentByokSpend: num, includeByokInQuota: bool, refreshPeriod: any, active: bool, archived: bool, alertThresholds: [num], createdAt: num, updatedAt: num}, metadata: map}}
@errors {400, 401, 403, 409, 410, 429, 500}

@endgroup

@group kms
@endpoint GET /v1/kms/issuers
@optional {limit: int, next: str, teamId: str, slug: str}
@returns(200) {issuers: [map], pagination: map{count: num, next: str?}}
@errors {400, 401, 403, 410}

@endpoint POST /v1/kms/issuers
@required {name: str}
@optional {teamId: str, slug: str, algorithm: str(RS256/RS384/RS512/PS256/PS384/PS512/ES256/ES384/ES512)=RS512, claimsSchema: map, policy: any, importKey: str, importKeyId: str}
@returns(201) {algorithm: str, claimsSchema: map, createdAt: str, id: str, managedBy: str, name: str, origin: str, ownerId: str, policies: [any], signingKeys: [map], updatedAt: str}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/kms/issuers/{issuerId}/sign/message
@required {issuerId: str, message: str}
@returns(200) {algorithm: str, keyId: str, signature: str}
@errors {400, 401, 403, 404, 429}

@endpoint POST /v1/kms/issuers/{issuerId}/sign/token
@required {issuerId: str}
@optional {claims: map, headers: map, ttl: num=300}
@returns(200) {token: str}
@errors {400, 401, 403, 404, 429}

@endpoint POST /v1/kms/issuers/{issuerId}/keys
@required {issuerId: str}
@optional {teamId: str, slug: str, activation: str(automatic/manual), revokePreviousAfterHours: num, revokePreviousAt: any, importKey: str, importKeyId: str}
@returns(200) {activateAt: str, activatedAt: str, algorithm: str, certificatePem: str, createdAt: str, importKeyId: str, issuerId: str, keyId: str, publicKey: map{alg: str, key_ops: [str], kid: str, kty: str, use: str, x5c: [str], x5t#S256: str}, publicKeyFingerprint: str, publicKeyPem: str, revokeAt: str, status: str, updatedAt: str}
@errors {400, 401, 403, 404, 409, 410}

@endpoint POST /v1/kms/issuers/{issuerId}/keys/{keyId}/activate
@required {issuerId: str, keyId: str}
@optional {teamId: str, slug: str, revokePreviousAfterHours: num}
@returns(200) {activateAt: str, activatedAt: str, algorithm: str, certificatePem: str, createdAt: str, importKeyId: str, issuerId: str, keyId: str, publicKey: map{alg: str, key_ops: [str], kid: str, kty: str, use: str, x5c: [str], x5t#S256: str}, publicKeyFingerprint: str, publicKeyPem: str, revokeAt: str, status: str, updatedAt: str}
@errors {400, 401, 403, 404, 409, 410}

@endpoint POST /v1/kms/issuers/{issuerId}/keys/{keyId}/revoke
@required {issuerId: str, keyId: str}
@optional {teamId: str, slug: str}
@returns(200) {algorithm: str, claimsSchema: map, createdAt: str, id: str, managedBy: str, name: str, origin: str, ownerId: str, policies: [any], signingKeys: [map], updatedAt: str}
@errors {400, 401, 403, 404, 409, 410}

@endpoint GET /v1/kms/issuers/{issuerId}
@required {issuerId: str}
@optional {teamId: str, slug: str}
@returns(200) {algorithm: str, claimsSchema: map, createdAt: str, id: str, managedBy: str, name: str, origin: str, ownerId: str, policies: [any], signingKeys: [map], updatedAt: str}
@errors {400, 401, 403, 404, 410}

@endpoint PATCH /v1/kms/issuers/{issuerId}
@required {issuerId: str}
@optional {teamId: str, slug: str, name: str, claimsSchema: map}
@returns(200) {algorithm: str, claimsSchema: map, createdAt: str, id: str, managedBy: str, name: str, origin: str, ownerId: str, policies: [any], signingKeys: [map], updatedAt: str}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/kms/issuers/{issuerId}
@required {issuerId: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/kms/issuers/{issuerId}/policies
@required {issuerId: str, kind: str, projectId: str, environments: [str]}
@optional {teamId: str, slug: str, tokenClaims: map}
@returns(201)
@errors {400, 401, 403, 404, 410}

@endpoint PATCH /v1/kms/issuers/{issuerId}/policies/{kind}/{policyKey}
@required {issuerId: str, kind: str, policyKey: str}
@optional {teamId: str, slug: str, environments: [str], tokenClaims: map}
@returns(200)
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/kms/issuers/{issuerId}/policies/{kind}/{policyKey}
@required {issuerId: str, kind: str(project-grant/connex-grant), policyKey: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410}

@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, 410}

@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, 410}

@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, 410}

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

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

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

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

@endgroup

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

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

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

@endpoint GET /v1/microfrontends/projects/{projectIdOrName}/production-mfe-config
@required {projectIdOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {config: map?{$schema: str, applications: map, options: map{disableOverrides: bool, localProxyPort: num}, version: str}}
@errors {400, 401, 403, 404, 410, 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{createdAt: num, enablePolyrepoBranchRouting: bool, fallbackEnvironment: str, id: str, name: str, slug: str, updatedAt: num}}
@errors {400, 401, 403, 410, 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, 410}

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

@endpoint POST /v2/observability/query
@required {metric: str, scope: map}
@optional {aggregation: str, groupBy: [str], filter: str, limit: num, orderBy: str, orderDirection: str(asc/desc), granularity: map, startTime: str, endTime: str, bucketTimezone: str}
@returns(200)
@errors {400, 401, 402, 403, 408, 410, 413, 422, 500, 503}

@endpoint GET /v2/observability/schema
@returns(200) {metrics: [map]}
@errors {400, 401, 403, 410}

@endpoint GET /v2/observability/schema/{metricId}
@required {metricId: str}
@returns(200)
@errors {400, 401, 403, 410}

@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, 410}

@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, 410, 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, 410}

@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, 410}

@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{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, lastModified: num, ruleCount: num, s3Key: str}}
@errors {400, 401, 403, 409, 410, 500}

@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{description: str, enabled: bool, id: str, name: str, rawDest: str, rawSrc: str, route: map{caseSensitive: bool, check: bool, continue: bool, dest: str, destination: any, env: [str], has: [any], headers: map, important: bool, locale: map{cookie: str, redirect: map}, methods: [str], middleware: num, middlewarePath: str, middlewareRawSrc: [str], missing: [any], mitigate: map{action: str}, override: bool, respectOriginCacheControl: bool, source: str, src: str, status: num, statusCode: num, transforms: [any]}, routeType: str, srcSyntax: str, staged: bool}, version: map{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, lastModified: num, ruleCount: num, s3Key: str}}
@errors {400, 401, 403, 409, 410, 500}

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

@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{description: str, enabled: bool, id: str, name: str, rawDest: str, rawSrc: str, route: map{caseSensitive: bool, check: bool, continue: bool, dest: str, destination: any, env: [str], has: [any], headers: map, important: bool, locale: map{cookie: str, redirect: map}, methods: [str], middleware: num, middlewarePath: str, middlewareRawSrc: [str], missing: [any], mitigate: map{action: str}, override: bool, respectOriginCacheControl: bool, source: str, src: str, status: num, statusCode: num, transforms: [any]}, routeType: str, srcSyntax: str, staged: bool}, version: map{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, lastModified: num, ruleCount: num, s3Key: str}}
@errors {400, 401, 403, 404, 409, 410, 500}

@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) {error: str, route: map{actions: [map], conditions: [map], description: str, name: str, pathCondition: map{syntax: str, value: str}}}
@errors {400, 401, 403, 408, 410, 500}

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

@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{alias: str, createdBy: str, id: str, isLive: bool, isStaging: bool, lastModified: num, ruleCount: num, s3Key: str}}
@errors {400, 401, 403, 404, 409, 410, 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, 410}

@endpoint GET /v1/projects/traces
@required {projectId: str, requestId: str}
@optional {teamId: str, slug: str}
@returns(200) {trace: map{resources: [map], rootSpanId: str, spans: [map], traceId: str}}
@errors {400, 401, 403, 404, 410}

@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(container/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/tanstack-start-lovable/vitepress/vuepress/parcel/fastapi/flask/fasthtml/django/ash/factory-eve/eve/sanity/sanity-v2/storybook/nitro/hono/express/h3/koa/nestjs/elysia/fastify/xmcp/python/ruby/rust/axum/actix-web/bun/node/go/services/mastra), gitRepository: map{repo!: str, type!: any}, installCommand: str, skipGitConnectDuringLink: bool, ssoProtection: map{deploymentType!: str}, sandbox: map{region: any, failoverRegions: [any]}, outputDirectory: str, publicSource: bool, rootDirectory: str, serverlessFunctionRegion: str, serverlessFunctionZeroConfigFailover: any, oidcTokenConfig: map{enabled: bool, issuerMode: str}, enableAffectedProjectsDeployments: bool, resourceConfig: map{buildMachineType: any, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: any, functionZeroConfigFailover: any, elasticConcurrencyEnabled: bool, buildMachineSelection: any, buildMachineElasticLastUpdated: num, buildMachineElasticReason: any, buildMachineElasticTransition: map, isNSNBDisabled: bool, buildQueue: map, enableFunctionsBeta: bool}}
@returns(200) {abuse: map{block: map{action: str, actor: str, caseId: str, comment: str, createdAt: num, ineligibleForAppeal: bool, isCascading: bool, reason: str, registeredShaBlock: map{createdAt: str, createdBy: str, sha: str}, statusCode: num}, blockHistory: [any], history: [map], interstitial: bool, interstitialHistory: [map], scanner: str, updatedAt: num}, accountId: str, alias: [map], analytics: map{canceledAt: num?, disabledAt: num, enabledAt: num, id: str, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, autoExposeSystemEnvs: bool, avatar: str?, blobs: map{isDefaultApp: bool}, buildCommand: str?, commandForIgnoringBuildStep: str?, concurrencyBucketName: str, connectBuildsEnabled: bool, connectConfigurationId: str?, connectConfigurations: [map]?, createdAt: num, creator: any, crons: map{definitions: [map], deploymentId: str?, disabledAt: num?, enabledAt: num, updatedAt: num}, customEnvironments: [map], customerSupportCodeVisibility: bool, dataCache: map{storageSizeBytes: num?, unlimited: bool, userDisabled: bool}, defaultResourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, deploymentExpiration: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, deploymentPolicy: map?{deploymentSources: [map]?, gitSources: [map]?}, devCommand: str?, directoryListing: bool, dismissedToasts: [map], enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, env: [map], expiration: any, features: map{webAnalytics: bool}, framework: str?, gitComments: map{onCommit: bool, onPullRequest: bool}, gitForkProtection: bool, gitLFS: bool, gitProviderOptions: map{consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}, createDeployments: str, disableRepositoryDispatchEvents: bool, gitCommitStatus: bool, requireVerifiedCommits: bool}, hasActiveBranches: bool, hasDeployments: bool, id: str, installCommand: str?, internalRoutes: [any], ipBuckets: [map], jobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, lastAliasRequest: map?{fromDeploymentId: str?, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, toDeploymentId: str, type: str}, lastRollbackTarget: map?, latestDeployments: [map], link: any, live: bool, microfrontends: any, name: str, nodeVersion: str, oidcTokenConfig: map{enabled: bool, issuerMode: str}, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passiveConnectConfigurationId: str?, passport: map?{connectorId: str, deploymentType: str}, passwordProtection: map?, paused: bool, permissions: map{accessGroup: [str], agent: [str], aiGatewayApiKey: [str], aiGatewayApiKeyBypassAll: [str], aiGatewayApiKeyOwnedBySelf: [str], aiGatewayApiKeySpendAttribution: [str], aiGatewayApiKeyZdrExemption: [str], aiGatewayBudget: [str], aiGatewayCredits: [str], aiGatewayGuardrails: [str], aiGatewayPrivateModels: [str], aiGatewayRules: [str], aiGatewaySettings: [str], aiGatewayTranscripts: [str], aiGatewayTranscriptsSettings: [str], aiGatewayUsage: [str], aiGatewayVirtualModelConfigs: [str], alertRules: [str], alerts: [str], aliasGlobal: [str], aliasProject: [str], aliasProtectionBypass: [str], analytics: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], auditLog: [str], automation: [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], buildMachine: [str], buildMachineDefault: [str], bulkRedirects: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], ciInvocations: [str], ciLogs: [str], codeChecks: [str], codeOwners: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], connectConfigurationLink: [str], connectLogs: [str], connexClient: [str], connexClientProject: [str], connexContact: [str], connexInstallation: [str], connexToken: [str], cursorOriginInstallation: [str], dataCacheBillingSettings: [str], dataCacheNamespace: [str], defaultDeploymentProtection: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentPolicy: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentProductionGit: [str], deploymentPromote: [str], deploymentProtectionException: [str], deploymentRollback: [str], deploymentV0: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeCacheNamespace: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], environments: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitCredentialGrant: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationPullRequest: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStoreTokenSet: [str], integrationStrict: [str], integrationVercelConfigurationOverride: [str], ipBlocking: [str], job: [str], jobGlobal: [str], kmsIssuer: [str], kmsProjectGrant: [str], logDrain: [str], logs: [str], logsPreset: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceFlexCommit: [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], oauth2Application: [str], oauth2Connection: [str], observabilityConfiguration: [str], observabilityData: [str], observabilityFunnel: [str], observabilityNotebook: [str], oidcFederationPolicy: [str], onDemandBuild: [str], onDemandConcurrency: [str], openTelemetryEndpoint: [str], optionsAllowlist: [str], organization: [str], organizationDomain: [str], organizationTeam: [str], ownEvent: [str], pageIntegrity: [str], passwordProtection: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], productionShareableLink: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectDomainVerify: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectEvent: [str], projectFlags: [str], projectFlagsProduction: [str], projectFlagsSdkKey: [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], projectSetting: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferIn: [str], projectTransferOut: [str], projectTransferRequest: [str], projectUsage: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], schedule: [str], seawallConfig: [str], secret: [str], securityConfig: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], setting: [str], shareableLink: [str], shareableLinkStrict: [str], sharedEnvVarConnection: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], skewProtection: [str], space: [str], spaceRun: [str], storeIsLocked: [str], storeTokenSetSensitive: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamInviteLink: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], teamSudo: [str], teamTokenInvalidation: [str], token: [str], toolbarComment: [str], trustedIps: [str], trustedSources: [str], usage: [str], usageCycle: [str], user: [str], userConnection: [str], userMfaConfiguration: [str], userPreference: [str], userSudo: [str], v0Chat: [str], vcrRepository: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], vercelAuth: [str], vercelRun: [str], vpcPeeringConnection: [str], webAnalytics: [str], webAnalyticsPlan: [str], webAuthn: [str], webhook: [str], webhook-event: [str], workflowRunData: [str]}, productionDeploymentsFastLane: bool, protectedSourcemaps: bool, protectionBypass: map, protectionConfig: map{sandboxUrls: map{inheritDeploymentProtection: bool}}, resourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, rollbackDescription: map{createdAt: num, description: str, userId: str, username: str}, rollingRelease: map?{canaryResponseHeader: bool, gate: map{action: str, checks: [map], dryRun: bool, enabled: bool, failureThreshold: num, windowSize: num}, stages: [map]?, target: str}, rootDirectory: str?, sandbox: map{failoverRegions: [str], region: str}, security: map{attackModeActiveUntil: num?, attackModeEnabled: bool, attackModeUpdatedAt: num, botIdEnabled: bool, firewallBypassIps: [str], firewallConfigVersion: num, firewallEnabled: bool, firewallSeawallEnabled: bool, firewallUpdatedAt: num, ja3Enabled: bool, ja4Enabled: bool, log_headers: any, managedRules: map?{ai_bots: map{action: str, active: bool}, bot_filter: map{action: str, active: bool}, owasp: map{action: str, active: bool}, traffic_sources: map{action: str, active: bool}, vercel_ruleset: map{action: str, active: bool}}, pageIntegrityEnabled: bool, rulesets: map}, serverlessFunctionZeroConfigFailover: bool, services: [map], skewProtectionAllowedDomains: [str], skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, speedInsights: map{canceledAt: num, dataReceivedAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str, paidAt: num}, ssoProtection: map?{april2026SecurityIncidentMigrationAppliedFrom: str?, cve55182MigrationAppliedFrom: str?, deploymentType: str}, staticIps: map{builds: bool, enabled: bool, regions: [str]}, targets: map, tier: str, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, transferCompletedAt: num, transferredFromAccountId: str, transferStartedAt: num, transferToAccountId: str, trustedIps: any?, trustedSources: map?{enableVercelCiSameRepository: bool, oidcProviders: map, projects: map}, updatedAt: num, usageStatus: map{bypassThrottleUntil: num, exceededAllowanceUntil: num, kind: str, teamThrottled: bool, throttled: bool}, v0: bool, v0Created: bool, webAnalytics: map{canceledAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str}}
@errors {400, 401, 402, 403, 404, 409, 410, 428, 429, 500}

@endpoint POST /v1/projects/{idOrName}/token
@required {idOrName: str}
@optional {teamId: str, slug: str, source: str}
@returns(200) {token: str}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/projects/traces/session
@required {projectId: str, hostname: str}
@optional {teamId: str, slug: str}
@returns(200) {token: str}
@errors {400, 401, 403, 410, 422}

@endpoint GET /v9/projects/{idOrName}
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {abuse: map{block: map{action: str, actor: str, caseId: str, comment: str, createdAt: num, ineligibleForAppeal: bool, isCascading: bool, reason: str, registeredShaBlock: map{createdAt: str, createdBy: str, sha: str}, statusCode: num}, blockHistory: [any], history: [map], interstitial: bool, interstitialHistory: [map], scanner: str, updatedAt: num}, accountId: str, alias: [map], analytics: map{canceledAt: num?, disabledAt: num, enabledAt: num, id: str, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, autoExposeSystemEnvs: bool, avatar: str?, blobs: map{isDefaultApp: bool}, buildCommand: str?, commandForIgnoringBuildStep: str?, concurrencyBucketName: str, connectBuildsEnabled: bool, connectConfigurationId: str?, connectConfigurations: [map]?, createdAt: num, creator: any, crons: map{definitions: [map], deploymentId: str?, disabledAt: num?, enabledAt: num, updatedAt: num}, customEnvironments: [map], customerSupportCodeVisibility: bool, dataCache: map{storageSizeBytes: num?, unlimited: bool, userDisabled: bool}, defaultResourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, deploymentExpiration: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, deploymentPolicy: map?{deploymentSources: [map]?, gitSources: [map]?}, devCommand: str?, directoryListing: bool, dismissedToasts: [map], enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, env: [map], expiration: any, features: map{webAnalytics: bool}, framework: str?, gitComments: map{onCommit: bool, onPullRequest: bool}, gitForkProtection: bool, gitLFS: bool, gitProviderOptions: map{consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}, createDeployments: str, disableRepositoryDispatchEvents: bool, gitCommitStatus: bool, requireVerifiedCommits: bool}, hasActiveBranches: bool, hasDeployments: bool, id: str, installCommand: str?, integrations: [map], internalRoutes: [any], ipBuckets: [map], jobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, lastAliasRequest: map?{fromDeploymentId: str?, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, toDeploymentId: str, type: str}, lastRollbackTarget: map?, latestDeployments: [map], link: any, live: bool, microfrontends: any, name: str, nodeVersion: str, oidcTokenConfig: map{enabled: bool, issuerMode: str}, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passiveConnectConfigurationId: str?, passport: map?{connectorId: str, deploymentType: str}, passwordProtection: map?, paused: bool, permissions: map{accessGroup: [str], agent: [str], aiGatewayApiKey: [str], aiGatewayApiKeyBypassAll: [str], aiGatewayApiKeyOwnedBySelf: [str], aiGatewayApiKeySpendAttribution: [str], aiGatewayApiKeyZdrExemption: [str], aiGatewayBudget: [str], aiGatewayCredits: [str], aiGatewayGuardrails: [str], aiGatewayPrivateModels: [str], aiGatewayRules: [str], aiGatewaySettings: [str], aiGatewayTranscripts: [str], aiGatewayTranscriptsSettings: [str], aiGatewayUsage: [str], aiGatewayVirtualModelConfigs: [str], alertRules: [str], alerts: [str], aliasGlobal: [str], aliasProject: [str], aliasProtectionBypass: [str], analytics: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], auditLog: [str], automation: [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], buildMachine: [str], buildMachineDefault: [str], bulkRedirects: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], ciInvocations: [str], ciLogs: [str], codeChecks: [str], codeOwners: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], connectConfigurationLink: [str], connectLogs: [str], connexClient: [str], connexClientProject: [str], connexContact: [str], connexInstallation: [str], connexToken: [str], cursorOriginInstallation: [str], dataCacheBillingSettings: [str], dataCacheNamespace: [str], defaultDeploymentProtection: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentPolicy: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentProductionGit: [str], deploymentPromote: [str], deploymentProtectionException: [str], deploymentRollback: [str], deploymentV0: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeCacheNamespace: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], environments: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitCredentialGrant: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationPullRequest: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStoreTokenSet: [str], integrationStrict: [str], integrationVercelConfigurationOverride: [str], ipBlocking: [str], job: [str], jobGlobal: [str], kmsIssuer: [str], kmsProjectGrant: [str], logDrain: [str], logs: [str], logsPreset: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceFlexCommit: [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], oauth2Application: [str], oauth2Connection: [str], observabilityConfiguration: [str], observabilityData: [str], observabilityFunnel: [str], observabilityNotebook: [str], oidcFederationPolicy: [str], onDemandBuild: [str], onDemandConcurrency: [str], openTelemetryEndpoint: [str], optionsAllowlist: [str], organization: [str], organizationDomain: [str], organizationTeam: [str], ownEvent: [str], pageIntegrity: [str], passwordProtection: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], productionShareableLink: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectDomainVerify: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectEvent: [str], projectFlags: [str], projectFlagsProduction: [str], projectFlagsSdkKey: [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], projectSetting: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferIn: [str], projectTransferOut: [str], projectTransferRequest: [str], projectUsage: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], schedule: [str], seawallConfig: [str], secret: [str], securityConfig: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], setting: [str], shareableLink: [str], shareableLinkStrict: [str], sharedEnvVarConnection: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], skewProtection: [str], space: [str], spaceRun: [str], storeIsLocked: [str], storeTokenSetSensitive: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamInviteLink: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], teamSudo: [str], teamTokenInvalidation: [str], token: [str], toolbarComment: [str], trustedIps: [str], trustedSources: [str], usage: [str], usageCycle: [str], user: [str], userConnection: [str], userMfaConfiguration: [str], userPreference: [str], userSudo: [str], v0Chat: [str], vcrRepository: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], vercelAuth: [str], vercelRun: [str], vpcPeeringConnection: [str], webAnalytics: [str], webAnalyticsPlan: [str], webAuthn: [str], webhook: [str], webhook-event: [str], workflowRunData: [str]}, productionDeploymentsFastLane: bool, protectedSourcemaps: bool, protectionBypass: map, protectionConfig: map{sandboxUrls: map{inheritDeploymentProtection: bool}}, resourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, rollbackDescription: map{createdAt: num, description: str, userId: str, username: str}, rollingRelease: map?{canaryResponseHeader: bool, gate: map{action: str, checks: [map], dryRun: bool, enabled: bool, failureThreshold: num, windowSize: num}, stages: [map]?, target: str}, rootDirectory: str?, sandbox: map{failoverRegions: [str], region: str}, security: map{attackModeActiveUntil: num?, attackModeEnabled: bool, attackModeUpdatedAt: num, botIdEnabled: bool, firewallBypassIps: [str], firewallConfigVersion: num, firewallEnabled: bool, firewallSeawallEnabled: bool, firewallUpdatedAt: num, ja3Enabled: bool, ja4Enabled: bool, log_headers: any, managedRules: map?{ai_bots: map{action: str, active: bool}, bot_filter: map{action: str, active: bool}, owasp: map{action: str, active: bool}, traffic_sources: map{action: str, active: bool}, vercel_ruleset: map{action: str, active: bool}}, pageIntegrityEnabled: bool, rulesets: map}, serverlessFunctionZeroConfigFailover: bool, services: [map], skewProtectionAllowedDomains: [str], skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, speedInsights: map{canceledAt: num, dataReceivedAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str, paidAt: num}, ssoProtection: map?{april2026SecurityIncidentMigrationAppliedFrom: str?, cve55182MigrationAppliedFrom: str?, deploymentType: str}, staticIps: map{builds: bool, enabled: bool, regions: [str]}, targets: map, tier: str, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, transferCompletedAt: num, transferredFromAccountId: str, transferStartedAt: num, transferToAccountId: str, trustedIps: any?, trustedSources: map?{enableVercelCiSameRepository: bool, oidcProviders: map, projects: map}, updatedAt: num, usageStatus: map{bypassThrottleUntil: num, exceededAllowanceUntil: num, kind: str, teamThrottled: bool, throttled: bool}, v0: bool, v0Created: bool, webAnalytics: map{canceledAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str}}
@errors {400, 401, 403, 410}

@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(container/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/tanstack-start-lovable/vitepress/vuepress/parcel/fastapi/flask/fasthtml/django/ash/factory-eve/eve/sanity/sanity-v2/storybook/nitro/hono/express/h3/koa/nestjs/elysia/fastify/xmcp/python/ruby/rust/axum/actix-web/bun/node/go/services/mastra), 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, resourceConfig: map{buildMachineType: any, buildMachineSelection: str, buildQueue: map, fluid: bool, functionDefaultRegions: [str], functionDefaultTimeout: num, functionDefaultMemoryType: any, functionZeroConfigFailover: any, elasticConcurrencyEnabled: bool, buildMachineElasticLastUpdated: num, buildMachineElasticReason: any, buildMachineElasticTransition: map, isNSNBDisabled: bool, enableFunctionsBeta: bool}, publicSource: 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}, passport: map{connectorId!: str, deploymentType: str}, sandbox: map{region: any, failoverRegions: [any]}, ssoProtection: map{deploymentType!: str}, trustedIps: map{deploymentType!: str, addresses!: [map], protectionMode!: str}, trustedSources: map{enableVercelCiSameRepository: bool, projects: map, oidcProviders: map}, deploymentPolicy: any, optionsAllowlist: map{paths!: [map]}, connectConfigurations: [any], dismissedToasts: [map{key!: str, dismissedAt!: num, action!: any, value!: any}]}
@returns(200) {abuse: map{block: map{action: str, actor: str, caseId: str, comment: str, createdAt: num, ineligibleForAppeal: bool, isCascading: bool, reason: str, registeredShaBlock: map{createdAt: str, createdBy: str, sha: str}, statusCode: num}, blockHistory: [any], history: [map], interstitial: bool, interstitialHistory: [map], scanner: str, updatedAt: num}, accountId: str, alias: [map], analytics: map{canceledAt: num?, disabledAt: num, enabledAt: num, id: str, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, autoExposeSystemEnvs: bool, avatar: str?, blobs: map{isDefaultApp: bool}, buildCommand: str?, commandForIgnoringBuildStep: str?, concurrencyBucketName: str, connectBuildsEnabled: bool, connectConfigurationId: str?, connectConfigurations: [map]?, createdAt: num, creator: any, crons: map{definitions: [map], deploymentId: str?, disabledAt: num?, enabledAt: num, updatedAt: num}, customEnvironments: [map], customerSupportCodeVisibility: bool, dataCache: map{storageSizeBytes: num?, unlimited: bool, userDisabled: bool}, defaultResourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, deploymentExpiration: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, deploymentPolicy: map?{deploymentSources: [map]?, gitSources: [map]?}, devCommand: str?, directoryListing: bool, dismissedToasts: [map], enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, env: [map], expiration: any, features: map{webAnalytics: bool}, framework: str?, gitComments: map{onCommit: bool, onPullRequest: bool}, gitForkProtection: bool, gitLFS: bool, gitProviderOptions: map{consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}, createDeployments: str, disableRepositoryDispatchEvents: bool, gitCommitStatus: bool, requireVerifiedCommits: bool}, hasActiveBranches: bool, hasDeployments: bool, id: str, installCommand: str?, internalRoutes: [any], ipBuckets: [map], jobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, lastAliasRequest: map?{fromDeploymentId: str?, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, toDeploymentId: str, type: str}, lastRollbackTarget: map?, latestDeployments: [map], link: any, live: bool, microfrontends: any, name: str, nodeVersion: str, oidcTokenConfig: map{enabled: bool, issuerMode: str}, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passiveConnectConfigurationId: str?, passport: map?{connectorId: str, deploymentType: str}, passwordProtection: map?, paused: bool, permissions: map{accessGroup: [str], agent: [str], aiGatewayApiKey: [str], aiGatewayApiKeyBypassAll: [str], aiGatewayApiKeyOwnedBySelf: [str], aiGatewayApiKeySpendAttribution: [str], aiGatewayApiKeyZdrExemption: [str], aiGatewayBudget: [str], aiGatewayCredits: [str], aiGatewayGuardrails: [str], aiGatewayPrivateModels: [str], aiGatewayRules: [str], aiGatewaySettings: [str], aiGatewayTranscripts: [str], aiGatewayTranscriptsSettings: [str], aiGatewayUsage: [str], aiGatewayVirtualModelConfigs: [str], alertRules: [str], alerts: [str], aliasGlobal: [str], aliasProject: [str], aliasProtectionBypass: [str], analytics: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], auditLog: [str], automation: [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], buildMachine: [str], buildMachineDefault: [str], bulkRedirects: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], ciInvocations: [str], ciLogs: [str], codeChecks: [str], codeOwners: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], connectConfigurationLink: [str], connectLogs: [str], connexClient: [str], connexClientProject: [str], connexContact: [str], connexInstallation: [str], connexToken: [str], cursorOriginInstallation: [str], dataCacheBillingSettings: [str], dataCacheNamespace: [str], defaultDeploymentProtection: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentPolicy: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentProductionGit: [str], deploymentPromote: [str], deploymentProtectionException: [str], deploymentRollback: [str], deploymentV0: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeCacheNamespace: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], environments: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitCredentialGrant: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationPullRequest: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStoreTokenSet: [str], integrationStrict: [str], integrationVercelConfigurationOverride: [str], ipBlocking: [str], job: [str], jobGlobal: [str], kmsIssuer: [str], kmsProjectGrant: [str], logDrain: [str], logs: [str], logsPreset: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceFlexCommit: [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], oauth2Application: [str], oauth2Connection: [str], observabilityConfiguration: [str], observabilityData: [str], observabilityFunnel: [str], observabilityNotebook: [str], oidcFederationPolicy: [str], onDemandBuild: [str], onDemandConcurrency: [str], openTelemetryEndpoint: [str], optionsAllowlist: [str], organization: [str], organizationDomain: [str], organizationTeam: [str], ownEvent: [str], pageIntegrity: [str], passwordProtection: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], productionShareableLink: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectDomainVerify: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectEvent: [str], projectFlags: [str], projectFlagsProduction: [str], projectFlagsSdkKey: [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], projectSetting: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferIn: [str], projectTransferOut: [str], projectTransferRequest: [str], projectUsage: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], schedule: [str], seawallConfig: [str], secret: [str], securityConfig: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], setting: [str], shareableLink: [str], shareableLinkStrict: [str], sharedEnvVarConnection: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], skewProtection: [str], space: [str], spaceRun: [str], storeIsLocked: [str], storeTokenSetSensitive: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamInviteLink: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], teamSudo: [str], teamTokenInvalidation: [str], token: [str], toolbarComment: [str], trustedIps: [str], trustedSources: [str], usage: [str], usageCycle: [str], user: [str], userConnection: [str], userMfaConfiguration: [str], userPreference: [str], userSudo: [str], v0Chat: [str], vcrRepository: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], vercelAuth: [str], vercelRun: [str], vpcPeeringConnection: [str], webAnalytics: [str], webAnalyticsPlan: [str], webAuthn: [str], webhook: [str], webhook-event: [str], workflowRunData: [str]}, productionDeploymentsFastLane: bool, protectedSourcemaps: bool, protectionBypass: map, protectionConfig: map{sandboxUrls: map{inheritDeploymentProtection: bool}}, resourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, rollbackDescription: map{createdAt: num, description: str, userId: str, username: str}, rollingRelease: map?{canaryResponseHeader: bool, gate: map{action: str, checks: [map], dryRun: bool, enabled: bool, failureThreshold: num, windowSize: num}, stages: [map]?, target: str}, rootDirectory: str?, sandbox: map{failoverRegions: [str], region: str}, security: map{attackModeActiveUntil: num?, attackModeEnabled: bool, attackModeUpdatedAt: num, botIdEnabled: bool, firewallBypassIps: [str], firewallConfigVersion: num, firewallEnabled: bool, firewallSeawallEnabled: bool, firewallUpdatedAt: num, ja3Enabled: bool, ja4Enabled: bool, log_headers: any, managedRules: map?{ai_bots: map{action: str, active: bool}, bot_filter: map{action: str, active: bool}, owasp: map{action: str, active: bool}, traffic_sources: map{action: str, active: bool}, vercel_ruleset: map{action: str, active: bool}}, pageIntegrityEnabled: bool, rulesets: map}, serverlessFunctionZeroConfigFailover: bool, services: [map], skewProtectionAllowedDomains: [str], skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, speedInsights: map{canceledAt: num, dataReceivedAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str, paidAt: num}, ssoProtection: map?{april2026SecurityIncidentMigrationAppliedFrom: str?, cve55182MigrationAppliedFrom: str?, deploymentType: str}, staticIps: map{builds: bool, enabled: bool, regions: [str]}, targets: map, tier: str, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, transferCompletedAt: num, transferredFromAccountId: str, transferStartedAt: num, transferToAccountId: str, trustedIps: any?, trustedSources: map?{enableVercelCiSameRepository: bool, oidcProviders: map, projects: map}, updatedAt: num, usageStatus: map{bypassThrottleUntil: num, exceededAllowanceUntil: num, kind: str, teamThrottled: bool, throttled: bool}, v0: bool, v0Created: bool, webAnalytics: map{canceledAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str}}
@errors {400, 401, 402, 403, 404, 409, 410, 428, 429}

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

@endpoint POST /v1/projects/{idOrName}/avatar
@required {idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {abuse: map{block: map{action: str, actor: str, caseId: str, comment: str, createdAt: num, ineligibleForAppeal: bool, isCascading: bool, reason: str, registeredShaBlock: map{createdAt: str, createdBy: str, sha: str}, statusCode: num}, blockHistory: [any], history: [map], interstitial: bool, interstitialHistory: [map], scanner: str, updatedAt: num}, accountId: str, alias: [map], analytics: map{canceledAt: num?, disabledAt: num, enabledAt: num, id: str, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, autoExposeSystemEnvs: bool, avatar: str?, blobs: map{isDefaultApp: bool}, buildCommand: str?, commandForIgnoringBuildStep: str?, concurrencyBucketName: str, connectBuildsEnabled: bool, connectConfigurationId: str?, connectConfigurations: [map]?, createdAt: num, creator: any, crons: map{definitions: [map], deploymentId: str?, disabledAt: num?, enabledAt: num, updatedAt: num}, customEnvironments: [map], customerSupportCodeVisibility: bool, dataCache: map{storageSizeBytes: num?, unlimited: bool, userDisabled: bool}, defaultResourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, deploymentExpiration: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, deploymentPolicy: map?{deploymentSources: [map]?, gitSources: [map]?}, devCommand: str?, directoryListing: bool, dismissedToasts: [map], enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, env: [map], expiration: any, features: map{webAnalytics: bool}, framework: str?, gitComments: map{onCommit: bool, onPullRequest: bool}, gitForkProtection: bool, gitLFS: bool, gitProviderOptions: map{consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}, createDeployments: str, disableRepositoryDispatchEvents: bool, gitCommitStatus: bool, requireVerifiedCommits: bool}, hasActiveBranches: bool, hasDeployments: bool, id: str, installCommand: str?, internalRoutes: [any], ipBuckets: [map], jobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, lastAliasRequest: map?{fromDeploymentId: str?, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, toDeploymentId: str, type: str}, lastRollbackTarget: map?, latestDeployments: [map], link: any, live: bool, microfrontends: any, name: str, nodeVersion: str, oidcTokenConfig: map{enabled: bool, issuerMode: str}, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passiveConnectConfigurationId: str?, passport: map?{connectorId: str, deploymentType: str}, passwordProtection: map?, paused: bool, permissions: map{accessGroup: [str], agent: [str], aiGatewayApiKey: [str], aiGatewayApiKeyBypassAll: [str], aiGatewayApiKeyOwnedBySelf: [str], aiGatewayApiKeySpendAttribution: [str], aiGatewayApiKeyZdrExemption: [str], aiGatewayBudget: [str], aiGatewayCredits: [str], aiGatewayGuardrails: [str], aiGatewayPrivateModels: [str], aiGatewayRules: [str], aiGatewaySettings: [str], aiGatewayTranscripts: [str], aiGatewayTranscriptsSettings: [str], aiGatewayUsage: [str], aiGatewayVirtualModelConfigs: [str], alertRules: [str], alerts: [str], aliasGlobal: [str], aliasProject: [str], aliasProtectionBypass: [str], analytics: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], auditLog: [str], automation: [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], buildMachine: [str], buildMachineDefault: [str], bulkRedirects: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], ciInvocations: [str], ciLogs: [str], codeChecks: [str], codeOwners: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], connectConfigurationLink: [str], connectLogs: [str], connexClient: [str], connexClientProject: [str], connexContact: [str], connexInstallation: [str], connexToken: [str], cursorOriginInstallation: [str], dataCacheBillingSettings: [str], dataCacheNamespace: [str], defaultDeploymentProtection: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentPolicy: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentProductionGit: [str], deploymentPromote: [str], deploymentProtectionException: [str], deploymentRollback: [str], deploymentV0: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeCacheNamespace: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], environments: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitCredentialGrant: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationPullRequest: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStoreTokenSet: [str], integrationStrict: [str], integrationVercelConfigurationOverride: [str], ipBlocking: [str], job: [str], jobGlobal: [str], kmsIssuer: [str], kmsProjectGrant: [str], logDrain: [str], logs: [str], logsPreset: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceFlexCommit: [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], oauth2Application: [str], oauth2Connection: [str], observabilityConfiguration: [str], observabilityData: [str], observabilityFunnel: [str], observabilityNotebook: [str], oidcFederationPolicy: [str], onDemandBuild: [str], onDemandConcurrency: [str], openTelemetryEndpoint: [str], optionsAllowlist: [str], organization: [str], organizationDomain: [str], organizationTeam: [str], ownEvent: [str], pageIntegrity: [str], passwordProtection: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], productionShareableLink: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectDomainVerify: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectEvent: [str], projectFlags: [str], projectFlagsProduction: [str], projectFlagsSdkKey: [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], projectSetting: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferIn: [str], projectTransferOut: [str], projectTransferRequest: [str], projectUsage: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], schedule: [str], seawallConfig: [str], secret: [str], securityConfig: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], setting: [str], shareableLink: [str], shareableLinkStrict: [str], sharedEnvVarConnection: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], skewProtection: [str], space: [str], spaceRun: [str], storeIsLocked: [str], storeTokenSetSensitive: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamInviteLink: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], teamSudo: [str], teamTokenInvalidation: [str], token: [str], toolbarComment: [str], trustedIps: [str], trustedSources: [str], usage: [str], usageCycle: [str], user: [str], userConnection: [str], userMfaConfiguration: [str], userPreference: [str], userSudo: [str], v0Chat: [str], vcrRepository: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], vercelAuth: [str], vercelRun: [str], vpcPeeringConnection: [str], webAnalytics: [str], webAnalyticsPlan: [str], webAuthn: [str], webhook: [str], webhook-event: [str], workflowRunData: [str]}, productionDeploymentsFastLane: bool, protectedSourcemaps: bool, protectionBypass: map, protectionConfig: map{sandboxUrls: map{inheritDeploymentProtection: bool}}, resourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, rollbackDescription: map{createdAt: num, description: str, userId: str, username: str}, rollingRelease: map?{canaryResponseHeader: bool, gate: map{action: str, checks: [map], dryRun: bool, enabled: bool, failureThreshold: num, windowSize: num}, stages: [map]?, target: str}, rootDirectory: str?, sandbox: map{failoverRegions: [str], region: str}, security: map{attackModeActiveUntil: num?, attackModeEnabled: bool, attackModeUpdatedAt: num, botIdEnabled: bool, firewallBypassIps: [str], firewallConfigVersion: num, firewallEnabled: bool, firewallSeawallEnabled: bool, firewallUpdatedAt: num, ja3Enabled: bool, ja4Enabled: bool, log_headers: any, managedRules: map?{ai_bots: map{action: str, active: bool}, bot_filter: map{action: str, active: bool}, owasp: map{action: str, active: bool}, traffic_sources: map{action: str, active: bool}, vercel_ruleset: map{action: str, active: bool}}, pageIntegrityEnabled: bool, rulesets: map}, serverlessFunctionZeroConfigFailover: bool, services: [map], skewProtectionAllowedDomains: [str], skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, speedInsights: map{canceledAt: num, dataReceivedAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str, paidAt: num}, ssoProtection: map?{april2026SecurityIncidentMigrationAppliedFrom: str?, cve55182MigrationAppliedFrom: str?, deploymentType: str}, staticIps: map{builds: bool, enabled: bool, regions: [str]}, targets: map, tier: str, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, transferCompletedAt: num, transferredFromAccountId: str, transferStartedAt: num, transferToAccountId: str, trustedIps: any?, trustedSources: map?{enableVercelCiSameRepository: bool, oidcProviders: map, projects: map}, updatedAt: num, usageStatus: map{bypassThrottleUntil: num, exceededAllowanceUntil: num, kind: str, teamThrottled: bool, throttled: bool}, v0: bool, v0Created: bool, webAnalytics: map{canceledAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str}}
@errors {400, 401, 403, 410, 413, 415}

@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, 410, 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) {branchMatcher: map{pattern: str, type: str}, createdAt: num, currentDeploymentAliases: [str], description: str, domains: [map], id: str, slug: str, type: str, updatedAt: num}
@errors {400, 401, 402, 403, 410, 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, 410}

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

@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) {branchMatcher: map{pattern: str, type: str}, createdAt: num, currentDeploymentAliases: [str], description: str, domains: [map], id: str, slug: str, type: str, updatedAt: num}
@errors {400, 401, 402, 403, 410, 500}

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

@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, 410}

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

@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) {apexName: str, createdAt: num, customEnvironmentId: str?, gitBranch: str?, name: str, projectId: str, redirect: str?, redirectStatusCode: num?, updatedAt: num, verification: [map], verified: bool}
@errors {400, 401, 403, 409, 410}

@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, 410}

@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) {apexName: str, createdAt: num, customEnvironmentId: str?, gitBranch: str?, name: str, projectId: str, redirect: str?, redirectStatusCode: num?, updatedAt: num, verification: [map], verified: bool}
@errors {400, 401, 402, 403, 409, 410}

@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) {apexName: str, createdAt: num, customEnvironmentId: str?, gitBranch: str?, name: str, projectId: str, redirect: str?, redirectStatusCode: num?, updatedAt: num, verification: [map], verified: bool}
@errors {400, 401, 403, 409, 410}

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

@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, 410}

@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, 410, 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, 410}

@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, 410}

@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) {comment: str, configurationId: str?, contentHint: any?, createdAt: num, createdBy: str?, customEnvironmentIds: [str], decrypted: bool, edgeConfigId: str?, edgeConfigTokenId: str?, gitBranch: str, id: str, internalContentHint: map?{encryptedValue: str, type: str}, key: str, legacyValue: str, sunsetSecretId: str, target: any, type: str, updatedAt: num, updatedBy: str?, value: str, visibility: str}
@errors {400, 401, 403, 404, 409, 410, 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, 410}

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

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

@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, 410}

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

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

@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?{activeStage: map?{duration: num?, index: num, isFinalStage: bool, linearShift: bool, requireApproval: bool, targetPercentage: num}, advancementType: str, canaryDeployment: map?{createdAt: num, id: str, name: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, currentCanaryPercentage: num, currentDeployment: map?{createdAt: num, id: str, name: str, readyState: str, readyStateAt: num, source: str, target: str?, url: str}, nextStage: map?{duration: num?, index: num, isFinalStage: bool, linearShift: bool, requireApproval: bool, targetPercentage: num}, queuedDeploymentId: str?, stages: [map], startedAt: num, state: str, substate: str?, updatedAt: num}}
@errors {400, 401, 403, 404, 410, 500}

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

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

@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, 409, 410}

@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, 410, 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, 410}

@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, 410, 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, 410, 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) {abuse: map{block: map{action: str, actor: str, caseId: str, comment: str, createdAt: num, ineligibleForAppeal: bool, isCascading: bool, reason: str, registeredShaBlock: map{createdAt: str, createdBy: str, sha: str}, statusCode: num}, blockHistory: [any], history: [map], interstitial: bool, interstitialHistory: [map], scanner: str, updatedAt: num}, accountId: str, alias: [map], analytics: map{canceledAt: num?, disabledAt: num, enabledAt: num, id: str, paidAt: num, sampleRatePercent: num?, spendLimitInDollars: num?}, appliedCve55182Migration: bool, autoAssignCustomDomains: bool, autoAssignCustomDomainsUpdatedBy: str, autoExposeSystemEnvs: bool, avatar: str?, blobs: map{isDefaultApp: bool}, buildCommand: str?, commandForIgnoringBuildStep: str?, concurrencyBucketName: str, connectBuildsEnabled: bool, connectConfigurationId: str?, connectConfigurations: [map]?, createdAt: num, creator: any, crons: map{definitions: [map], deploymentId: str?, disabledAt: num?, enabledAt: num, updatedAt: num}, customEnvironments: [map], customerSupportCodeVisibility: bool, dataCache: map{storageSizeBytes: num?, unlimited: bool, userDisabled: bool}, defaultResourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, deploymentExpiration: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, deploymentPolicy: map?{deploymentSources: [map]?, gitSources: [map]?}, devCommand: str?, directoryListing: bool, dismissedToasts: [map], enableAffectedProjectsDeployments: bool, enableExternalRewriteCaching: bool, enablePreviewFeedback: bool?, enableProductionFeedback: bool?, env: [map], expiration: any, features: map{webAnalytics: bool}, framework: str?, gitComments: map{onCommit: bool, onPullRequest: bool}, gitForkProtection: bool, gitLFS: bool, gitProviderOptions: map{consolidatedGitCommitStatus: map{enabled: bool, propagateFailures: bool}, createDeployments: str, disableRepositoryDispatchEvents: bool, gitCommitStatus: bool, requireVerifiedCommits: bool}, hasActiveBranches: bool, hasDeployments: bool, id: str, installCommand: str?, internalRoutes: [any], ipBuckets: [map], jobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, lastAliasRequest: map?{fromDeploymentId: str?, fromRollingReleaseId: str, jobStatus: str, requestedAt: num, toDeploymentId: str, type: str}, lastRollbackTarget: map?, latestDeployments: [map], link: any, live: bool, microfrontends: any, name: str, nodeVersion: str, oidcTokenConfig: map{enabled: bool, issuerMode: str}, optionsAllowlist: map?{paths: [map]}, outputDirectory: str?, passiveConnectConfigurationId: str?, passport: map?{connectorId: str, deploymentType: str}, passwordProtection: map?, paused: bool, permissions: map{accessGroup: [str], agent: [str], aiGatewayApiKey: [str], aiGatewayApiKeyBypassAll: [str], aiGatewayApiKeyOwnedBySelf: [str], aiGatewayApiKeySpendAttribution: [str], aiGatewayApiKeyZdrExemption: [str], aiGatewayBudget: [str], aiGatewayCredits: [str], aiGatewayGuardrails: [str], aiGatewayPrivateModels: [str], aiGatewayRules: [str], aiGatewaySettings: [str], aiGatewayTranscripts: [str], aiGatewayTranscriptsSettings: [str], aiGatewayUsage: [str], aiGatewayVirtualModelConfigs: [str], alertRules: [str], alerts: [str], aliasGlobal: [str], aliasProject: [str], aliasProtectionBypass: [str], analytics: [str], analyticsSampling: [str], analyticsUsage: [str], apiKey: [str], apiKeyAiGateway: [str], apiKeyOwnedBySelf: [str], auditLog: [str], automation: [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], buildMachine: [str], buildMachineDefault: [str], bulkRedirects: [str], cacheArtifact: [str], cacheArtifactUsageEvent: [str], ciInvocations: [str], ciLogs: [str], codeChecks: [str], codeOwners: [str], concurrentBuilds: [str], connect: [str], connectConfiguration: [str], connectConfigurationLink: [str], connectLogs: [str], connexClient: [str], connexClientProject: [str], connexContact: [str], connexInstallation: [str], connexToken: [str], cursorOriginInstallation: [str], dataCacheBillingSettings: [str], dataCacheNamespace: [str], defaultDeploymentProtection: [str], deployment: [str], deploymentBuildLogs: [str], deploymentCheck: [str], deploymentCheckPreview: [str], deploymentCheckReRunFromProductionBranch: [str], deploymentPolicy: [str], deploymentPreview: [str], deploymentPrivate: [str], deploymentProductionGit: [str], deploymentPromote: [str], deploymentProtectionException: [str], deploymentRollback: [str], deploymentV0: [str], domain: [str], domainAcceptDelegation: [str], domainAuthCodes: [str], domainCertificate: [str], domainCheckConfig: [str], domainMove: [str], domainPurchase: [str], domainRecord: [str], domainTransferIn: [str], drain: [str], edgeCacheNamespace: [str], edgeConfig: [str], edgeConfigItem: [str], edgeConfigSchema: [str], edgeConfigToken: [str], endpointVerification: [str], environments: [str], event: [str], fileUpload: [str], flagsExplorerSubscription: [str], gitCredentialGrant: [str], gitRepository: [str], imageOptimizationNewPrice: [str], integration: [str], integrationAccount: [str], integrationConfiguration: [str], integrationConfigurationProjects: [str], integrationConfigurationRole: [str], integrationConfigurationTransfer: [str], integrationDeploymentAction: [str], integrationEvent: [str], integrationLog: [str], integrationPullRequest: [str], integrationResource: [str], integrationResourceData: [str], integrationResourceReplCommand: [str], integrationResourceSecrets: [str], integrationSSOSession: [str], integrationStoreTokenSet: [str], integrationStrict: [str], integrationVercelConfigurationOverride: [str], ipBlocking: [str], job: [str], jobGlobal: [str], kmsIssuer: [str], kmsProjectGrant: [str], logDrain: [str], logs: [str], logsPreset: [str], marketplaceBillingData: [str], marketplaceExperimentationEdgeConfigData: [str], marketplaceExperimentationItem: [str], marketplaceFlexCommit: [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], oauth2Application: [str], oauth2Connection: [str], observabilityConfiguration: [str], observabilityData: [str], observabilityFunnel: [str], observabilityNotebook: [str], oidcFederationPolicy: [str], onDemandBuild: [str], onDemandConcurrency: [str], openTelemetryEndpoint: [str], optionsAllowlist: [str], organization: [str], organizationDomain: [str], organizationTeam: [str], ownEvent: [str], pageIntegrity: [str], passwordProtection: [str], passwordProtectionInvoiceItem: [str], paymentMethod: [str], permissions: [str], postgres: [str], postgresStoreTokenSet: [str], previewDeploymentSuffix: [str], privateCloudAccount: [str], privateLinkEndpoint: [str], productionAliasProtectionBypass: [str], productionShareableLink: [str], project: [str], projectAccessGroup: [str], projectAnalyticsSampling: [str], projectAnalyticsUsage: [str], projectCheck: [str], projectCheckRun: [str], projectDeploymentExpiration: [str], projectDeploymentHook: [str], projectDeploymentProtectionStrict: [str], projectDomain: [str], projectDomainCheckConfig: [str], projectDomainMove: [str], projectDomainVerify: [str], projectEnvVars: [str], projectEnvVarsProduction: [str], projectEnvVarsUnownedByIntegration: [str], projectEvent: [str], projectFlags: [str], projectFlagsProduction: [str], projectFlagsSdkKey: [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], projectSetting: [str], projectSupportCase: [str], projectSupportCaseComment: [str], projectTier: [str], projectTransfer: [str], projectTransferIn: [str], projectTransferOut: [str], projectTransferRequest: [str], projectUsage: [str], proTrialOnboarding: [str], rateLimit: [str], redis: [str], redisStoreTokenSet: [str], remoteCaching: [str], repository: [str], samlConfig: [str], schedule: [str], seawallConfig: [str], secret: [str], securityConfig: [str], securityPlusConfiguration: [str], sensitiveEnvironmentVariablePolicy: [str], setting: [str], shareableLink: [str], shareableLinkStrict: [str], sharedEnvVarConnection: [str], sharedEnvVars: [str], sharedEnvVarsProduction: [str], skewProtection: [str], space: [str], spaceRun: [str], storeIsLocked: [str], storeTokenSetSensitive: [str], storeTransfer: [str], supportCase: [str], supportCaseComment: [str], team: [str], teamAccessRequest: [str], teamFellowMembership: [str], teamGitExclusivity: [str], teamInvite: [str], teamInviteCode: [str], teamInviteLink: [str], teamJoin: [str], teamMemberMfaStatus: [str], teamMicrofrontends: [str], teamOwnMembership: [str], teamOwnMembershipDisconnectSAML: [str], teamSudo: [str], teamTokenInvalidation: [str], token: [str], toolbarComment: [str], trustedIps: [str], trustedSources: [str], usage: [str], usageCycle: [str], user: [str], userConnection: [str], userMfaConfiguration: [str], userPreference: [str], userSudo: [str], v0Chat: [str], vcrRepository: [str], vercelAppInstallation: [str], vercelAppInstallationRequest: [str], vercelAuth: [str], vercelRun: [str], vpcPeeringConnection: [str], webAnalytics: [str], webAnalyticsPlan: [str], webAuthn: [str], webhook: [str], webhook-event: [str], workflowRunData: [str]}, productionDeploymentsFastLane: bool, protectedSourcemaps: bool, protectionBypass: map, protectionConfig: map{sandboxUrls: map{inheritDeploymentProtection: bool}}, resourceConfig: map{buildMachineElasticLastUpdated: num, buildMachineElasticReason: str, buildMachineElasticTransition: map{algorithmVersion: str, at: num, direction: str}, buildMachineSelection: str, buildMachineType: str, buildQueue: map{configuration: str}, elasticConcurrencyEnabled: bool, enableFunctionsBeta: bool, fluid: bool, functionDefaultMemoryType: str, functionDefaultRegions: [str], functionDefaultTimeout: num, functionZeroConfigFailover: bool, isNSNBDisabled: bool}, rollbackDescription: map{createdAt: num, description: str, userId: str, username: str}, rollingRelease: map?{canaryResponseHeader: bool, gate: map{action: str, checks: [map], dryRun: bool, enabled: bool, failureThreshold: num, windowSize: num}, stages: [map]?, target: str}, rootDirectory: str?, sandbox: map{failoverRegions: [str], region: str}, security: map{attackModeActiveUntil: num?, attackModeEnabled: bool, attackModeUpdatedAt: num, botIdEnabled: bool, firewallBypassIps: [str], firewallConfigVersion: num, firewallEnabled: bool, firewallSeawallEnabled: bool, firewallUpdatedAt: num, ja3Enabled: bool, ja4Enabled: bool, log_headers: any, managedRules: map?{ai_bots: map{action: str, active: bool}, bot_filter: map{action: str, active: bool}, owasp: map{action: str, active: bool}, traffic_sources: map{action: str, active: bool}, vercel_ruleset: map{action: str, active: bool}}, pageIntegrityEnabled: bool, rulesets: map}, serverlessFunctionZeroConfigFailover: bool, services: [map], skewProtectionAllowedDomains: [str], skewProtectionBoundaryAt: num, skewProtectionMaxAge: num, skipGitConnectDuringLink: bool, sourceFilesOutsideRootDirectory: bool, speedInsights: map{canceledAt: num, dataReceivedAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str, paidAt: num}, ssoProtection: map?{april2026SecurityIncidentMigrationAppliedFrom: str?, cve55182MigrationAppliedFrom: str?, deploymentType: str}, staticIps: map{builds: bool, enabled: bool, regions: [str]}, targets: map, tier: str, tracing: map{domains: str, ignorePaths: [str], samplingRules: [map]}, transferCompletedAt: num, transferredFromAccountId: str, transferStartedAt: num, transferToAccountId: str, trustedIps: any?, trustedSources: map?{enableVercelCiSameRepository: bool, oidcProviders: map, projects: map}, updatedAt: num, usageStatus: map{bypassThrottleUntil: num, exceededAllowanceUntil: num, kind: str, teamThrottled: bool, throttled: bool}, v0: bool, v0Created: bool, webAnalytics: map{canceledAt: num, disabledAt: num, enabledAt: num, hasData: bool, id: str}}
@errors {400, 401, 403, 409, 410, 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, 410, 422}

@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, 410}

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

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

@endgroup

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

@endpoint POST /v2/sandboxes
@optional {teamId: str, slug: str, networkPolicy: any, runtime: str(node22/node24/node26/python3.13)=node24, architecture: str(amd64/arm64), resources: map{vcpus: int, memory: int}, source: any, projectId: str, ports: [int], image: str, timeout: int, env: map=[object Object], mounts: map, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1,sfo1,cle1,cdg1,fra1,arn1,sin1,pdx1,lhr1,icn1,bom1,cpt1,dub1,gru1,hkg1,syd1,yul1,hnd1,kix1, failoverRegions: [str], networkId: str, name: str, persistent: bool=true, snapshotExpiration: any, keepLastSnapshots: map{count!: int, expiration: any, deleteEvicted: bool}, tags: map}
@returns(200) {routes: [map], sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}, session: map{abortedAt: num, activeCpuDurationMs: num, architecture: str, createdAt: num, cwd: str, duration: num, id: str, memory: num, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], injectionRules: [map], mode: str}, networkTransfer: map{egress: num, ingress: num}, projectId: str, region: str, requestedAt: num, requestedStopAt: num, runtime: str, snapshottedAt: num, sourceSandboxName: str, sourceSnapshotId: str, startedAt: num, status: str, stoppedAt: num, timeout: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

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

@endpoint POST /v2/sandboxes/drives/{name}
@required {name: str}
@optional {teamId: str, slug: str, projectId: str, maxSizeBytes: int, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1}
@returns(200) {drive: map{createdAt: num, currentSandboxName: str, currentSessionId: str, id: str, maxSizeBytes: num, name: str, projectId: str, region: str, updatedAt: num}}
@returns(201) {drive: map{createdAt: num, currentSandboxName: str, currentSessionId: str, id: str, maxSizeBytes: num, name: str, projectId: str, region: str, updatedAt: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 429}

@endpoint DELETE /v2/sandboxes/drives/{name}
@required {name: str}
@optional {projectId: str, teamId: str, slug: str}
@returns(200) {drive: map{createdAt: num, currentSandboxName: str, currentSessionId: str, id: str, maxSizeBytes: num, name: str, projectId: str, region: str, updatedAt: num}}
@errors {400, 401, 403, 404, 409, 410, 429}

@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, 410, 429}

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

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

@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, 410, 429, 500}

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

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

@endpoint PATCH /v2/sandboxes/{name}
@required {name: str}
@optional {projectId: str, resume: bool=false, teamId: str, slug: str, resources: map{vcpus: int, memory: int}, runtime: str(node22/node24/node26/python3.13), timeout: int, persistent: bool, snapshotExpiration: any, keepLastSnapshots: any, networkPolicy: any, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1), failoverRegions: [str], mounts: map, networkId: any, env: map, ports: [int], currentSnapshotId: str, tags: map}
@returns(200)
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

@endpoint DELETE /v2/sandboxes/{name}
@required {name: str}
@optional {projectId: str, deleteOrphanSnapshots: bool=false, teamId: str, slug: str}
@returns(200) {sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 403, 404, 410, 429}

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

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

@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{args: [str], cwd: str, durationMs: num, exitCode: num?, id: str, name: str, sessionId: str, startedAt: num}}
@errors {400, 401, 403, 404, 410, 422, 429, 500}

@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{args: [str], cwd: str, durationMs: num, exitCode: num?, id: str, name: str, sessionId: str, startedAt: num}}
@errors {400, 401, 403, 404, 410, 422, 429, 500}

@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, 404, 410, 422, 429, 500}

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

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

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

@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, 404, 410, 422, 429, 500}

@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, 404, 410, 422, 429, 500}

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

@endpoint POST /v2/sandboxes/{name}/fork
@required {name: str}
@optional {projectId: str, teamId: str, slug: str, networkPolicy: any, resources: map{vcpus: int, memory: int}, ports: [int], image: str, timeout: int, env: map=[object Object], mounts: map, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1,sfo1,cle1,cdg1,fra1,arn1,sin1,pdx1,lhr1,icn1,bom1,cpt1,dub1,gru1,hkg1,syd1,yul1,hnd1,kix1, failoverRegions: [str], networkId: str, name: str, persistent: bool, snapshotExpiration: any, keepLastSnapshots: map{count!: int, expiration: any, deleteEvicted: bool}, tags: map}
@returns(200) {routes: [map], sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}, session: map{abortedAt: num, activeCpuDurationMs: num, architecture: str, createdAt: num, cwd: str, duration: num, id: str, memory: num, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], injectionRules: [map], mode: str}, networkTransfer: map{egress: num, ingress: num}, projectId: str, region: str, requestedAt: num, requestedStopAt: num, runtime: str, snapshottedAt: num, sourceSandboxName: str, sourceSnapshotId: str, startedAt: num, status: str, stoppedAt: num, timeout: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

@endpoint POST /v3/sandboxes
@optional {teamId: str, slug: str, networkPolicy: any, architecture: str(amd64/arm64), resources: map{vcpus: int, memory: int}, source: any, projectId: str, ports: [int], image: str, timeout: int, env: map=[object Object], mounts: map, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1,sfo1,cle1,cdg1,fra1,arn1,sin1,pdx1,lhr1,icn1,bom1,cpt1,dub1,gru1,hkg1,syd1,yul1,hnd1,kix1, failoverRegions: [str], networkId: str, name: str, persistent: bool=true, snapshotExpiration: any, keepLastSnapshots: map{count!: int, expiration: any, deleteEvicted: bool}, tags: map}
@returns(200) {routes: [map], sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}, session: map{abortedAt: num, activeCpuDurationMs: num, architecture: str, createdAt: num, cwd: str, duration: num, id: str, memory: num, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], injectionRules: [map], mode: str}, networkTransfer: map{egress: num, ingress: num}, projectId: str, region: str, requestedAt: num, requestedStopAt: num, runtime: str, snapshottedAt: num, sourceSandboxName: str, sourceSnapshotId: str, startedAt: num, status: str, stoppedAt: num, timeout: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

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

@endpoint POST /v3/sandboxes/{name}/fork
@required {name: str}
@optional {projectId: str, teamId: str, slug: str, networkPolicy: any, resources: map{vcpus: int, memory: int}, ports: [int], image: str, timeout: int, env: map=[object Object], mounts: map, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1,sfo1,cle1,cdg1,fra1,arn1,sin1,pdx1,lhr1,icn1,bom1,cpt1,dub1,gru1,hkg1,syd1,yul1,hnd1,kix1, failoverRegions: [str], networkId: str, name: str, persistent: bool, snapshotExpiration: any, keepLastSnapshots: any, tags: map}
@returns(200) {routes: [map], sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}, session: map{abortedAt: num, activeCpuDurationMs: num, architecture: str, createdAt: num, cwd: str, duration: num, id: str, memory: num, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], injectionRules: [map], mode: str}, networkTransfer: map{egress: num, ingress: num}, projectId: str, region: str, requestedAt: num, requestedStopAt: num, runtime: str, snapshottedAt: num, sourceSandboxName: str, sourceSnapshotId: str, startedAt: num, status: str, stoppedAt: num, timeout: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

@endpoint POST /v4/sandboxes
@optional {teamId: str, slug: str, networkPolicy: any, architecture: str(amd64/arm64), resources: map{vcpus: int, memory: int}, source: any, projectId: str, ports: [int], image: str, timeout: int, env: map=[object Object], mounts: map, region: str(iad1/sfo1/cle1/cdg1/fra1/arn1/sin1/pdx1/lhr1/icn1/bom1/cpt1/dub1/gru1/hkg1/syd1/yul1/hnd1/kix1)=iad1,sfo1,cle1,cdg1,fra1,arn1,sin1,pdx1,lhr1,icn1,bom1,cpt1,dub1,gru1,hkg1,syd1,yul1,hnd1,kix1, failoverRegions: [str], networkId: str, name: str, persistent: bool=true, snapshotExpiration: any, keepLastSnapshots: any, tags: map}
@returns(200) {routes: [map], sandbox: map{architecture: str, createdAt: num, currentSessionId: str, currentSnapshotId: str, cwd: str, expiresAt: num, failoverRegions: [str], image: str, keepLastSnapshots: map{count: num, deleteEvicted: bool, expiration: num}, memory: num, mounts: map, name: str, networkId: str, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], mode: str, s3Key: str}, persistent: bool, region: str, runtime: str, snapshotExpiration: num, status: str, statusUpdatedAt: num, tags: map, timeout: num, totalActiveCpuDurationMs: num, totalDurationMs: num, totalEgressBytes: num, totalIngressBytes: num, updatedAt: num, vcpus: num}, session: map{abortedAt: num, activeCpuDurationMs: num, architecture: str, createdAt: num, cwd: str, duration: num, id: str, memory: num, networkPolicy: map{allowedCIDRs: [str], allowedDomains: [str], deniedCIDRs: [str], injectionRules: [map], mode: str}, networkTransfer: map{egress: num, ingress: num}, projectId: str, region: str, requestedAt: num, requestedStopAt: num, runtime: str, snapshottedAt: num, sourceSandboxName: str, sourceSnapshotId: str, startedAt: num, status: str, stoppedAt: num, timeout: num, updatedAt: num, vcpus: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 422, 429, 500, 502}

@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, 410}

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

@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}], rulesets: any, ips: [map{id: str, hostname!: str, ip!: str, notes: str, action!: str}], botIdEnabled: bool, logHeaders: any}
@returns(200) {active: map{botIdEnabled: bool, changes: [map], conditions: [map], crs: map{gen: map{action: str, active: bool}, java: map{action: str, active: bool}, lfi: map{action: str, active: bool}, ma: map{action: str, active: bool}, php: map{action: str, active: bool}, rce: map{action: str, active: bool}, rfi: map{action: str, active: bool}, sd: map{action: str, active: bool}, sf: map{action: str, active: bool}, sqli: map{action: str, active: bool}, xss: map{action: str, active: bool}}, firewallEnabled: bool, id: str, ips: [map], logHeaders: any, managedRules: map{ai_bots: map{action: str, active: bool, updatedAt: str, userId: str, username: str}, bot_protection: map{action: str, active: bool, updatedAt: str, userId: str, username: str}, owasp: map{action: str, active: bool, updatedAt: str, userId: str, username: str}, traffic_sources: map{action: str, active: bool, updatedAt: str, userId: str, username: str}, vercel_ruleset: map{action: str, active: bool, updatedAt: str, userId: str, username: str}}, ownerId: str, projectKey: str, rules: [any], rulesets: any, updatedAt: str, version: num}}
@errors {400, 401, 402, 403, 404, 410, 500}

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

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

@endpoint DELETE /v1/security/firewall/config/{configVersion}
@required {configVersion: str}
@returns(204)
@errors {400, 401, 403, 404, 410, 500}

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

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

@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) {pagination: map{Id: str, OwnerId: str}, result: [map]}
@errors {400, 401, 402, 403, 404, 410, 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, 402, 403, 404, 410, 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, 402, 403, 404, 410, 500}

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

@endpoint POST /v1/security/firewall/config/generate-rule
@optional {projectId: str, teamId: str, slug: str}
@returns(200) {error: str, rule: map{action: map{mitigate: map{action: str, actionDuration: str?, rateLimit: map?, redirect: map?}}, active: bool, conditionGroup: [map], description: str, name: str}}
@errors {400, 401, 403, 404, 408, 410, 500}

@endgroup

@group speed-insights
@endpoint POST /speed-insights/toggle
@required {projectId: str, value: bool}
@returns(200) {value: bool}
@errors {400, 401, 402, 403, 410}

@endgroup

@group storage
@endpoint GET /storage/stores/{id}
@required {id: str}
@optional {skip-metadata: bool, include-guides: bool}
@returns(200) {store: map{projectFilter: map{git: map{owners: [str], providers: any, repos: [str]}}, projectsMetadata: [map], status: str?, totalConnectedProjects: num, usageQuotaExceeded: bool}}
@errors {400, 401, 403, 404, 410}

@endpoint POST /storage/stores/blob
@required {name: str}
@optional {region: str(arn1/bom1/cdg1/cle1/cpt1/dub1/dxb1/fra1/gru1/hkg1/hnd1/iad1/icn1/kix1/lhr1/pdx1/sfo1/sin1/syd1/yul1), access: str(public/private)=public, projectId: str}
@returns(200) {store: map?{projectFilter: map{git: map{owners: [str], providers: any, repos: [str]}}, projectsMetadata: [map], status: str?, totalConnectedProjects: num, usageQuotaExceeded: bool, access: str, kind: str, projectId: str, count: num, isTokenExpired: bool, region: str, size: num}}
@errors {400, 401, 402, 403, 404, 409, 410, 429}

@endpoint DELETE /storage/stores/blob/{id}
@required {id: str}
@returns(200) {id: str}
@errors {400, 401, 403, 404, 409, 410}

@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/import-recommended-integrations/organization)=marketplace, billingPlanId: str, paymentMethodId: str, prepaymentAmountCents: num}
@returns(200) {store: map?{projectFilter: map{git: map{owners: [str], providers: any, repos: [str]}}, projectsMetadata: [map], status: str?, totalConnectedProjects: num, usageQuotaExceeded: bool, billingPlan: map{cost: str, description: str, details: [map], disabled: bool, effectiveDate: str, highlightedDetails: [map], id: str, initialCharge: str, maximumAmount: str, maximumAmountAutoPurchasePerPeriod: str, minimumAmount: str, name: str, paymentMethodRequired: bool, preauthorizationAmount: num, quote: [map], scope: str, type: str}, capabilities: map{agentTools: bool, autoSensitive: bool, billable: bool, mcp: bool, mcpReadonly: bool, projects: bool, secretRotation: any, secretsSync: bool, sso: bool, transferable: bool, v0: bool}, directPartnerConsoleUrl: str, externalResourceId: str, externalResourceStatus: str?, metadata: map, notification: map{href: str, level: str, message: str, title: str}, ownership: str, parentId: str, product: map{agentSkills: [str], capabilities: map{agentTools: bool, autoSensitive: bool, billable: bool, connectedImportResource: bool, databaseUI: bool, importResource: bool, linking: bool, mcp: bool, mcpReadonly: bool, nativeImportResource: bool, projects: bool, sandbox: bool, secretRotation: any, secretsSync: bool, sso: bool, transferable: bool, v0: bool, v0Flavors: bool}, disableResourceRenaming: bool, iconUrl: str, id: str, metadataSchema: map{properties: map, required: [str], type: str, ui:order: [str]}, name: str, projectConnectionScopes: [str], resourceLinks: [map], resourceTitle: str, shortDescription: str, showSSOLinkOnProjectConnection: bool, slug: str, tags: [str], repl: map{enabled: bool, supportsReadOnlyMode: bool, welcomeMessage: str}, guides: [map], integration: map{capabilities: map, flags: [str], icon: str, id: str, name: str, slug: str, supportsInstallationBillingPlans: bool}, integrationConfigurationId: str, logDrainStatus: str, primaryProtocol: str, supportedProtocols: [str]}, protocolSettings: map{authentication: map{appUrls: [map]}, experimentation: map{edgeConfigId: str, edgeConfigSyncingEnabled: bool, edgeConfigTokenId: str, globalConfigId: str, globalConfigSyncingEnabled: bool}}, secretRotationCompletedAt: num, secretRotationRequestedAt: num, secretRotationRequestedBy: str, secretRotationRequestedReason: str, secrets: [map], targets: [str]}}
@errors {400, 401, 402, 403, 404, 409, 410, 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) {emailInviteCodes: [map], members: [map], pagination: map{count: num, hasNext: bool, next: num?, prev: num?}}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v2/teams/{teamId}/members
@required {teamId: str}
@optional {slug: str}
@returns(200) {email: str, role: str, teamPermissions: [str], teamRoles: [str], uid: str, username: str}
@errors {400, 401, 403, 410, 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) {accessRequestedAt: num, bitbucket: map?{login: str}, confirmed: bool, github: map?{login: str}, gitlab: map?{login: str}, joinedFrom: map{commitId: str, dsyncConnectedAt: num, dsyncUserId: str, gitUserId: any, gitUserLogin: str, idpUserId: str, origin: str, repoId: str, repoPath: str, ssoConnectedAt: num, ssoUserId: str}, teamName: str, teamSlug: str}
@errors {400, 401, 403, 404, 410, 429, 503}

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

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

@endpoint PATCH /v1/teams/{teamId}/members/{uid}
@required {uid: str, teamId: str}
@optional {confirmed: bool, role: str=MEMBER, teamPermissions: [str], projects: [map{projectId!: str, role!: str}], joinedFrom: map{ssoUserId: any}}
@returns(200) {id: str}
@errors {400, 401, 402, 403, 404, 409, 410, 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, 410, 503}

@endpoint GET /v2/teams/{teamId}
@required {teamId: str}
@optional {slug: str}
@returns(200) {apiKeysInvalidatedAt: num, appTokensInvalidatedAt: num, avatar: str?, billing: map?{plan: str}, connect: map{enabled: bool}, createdAt: num, creatorId: str, defaultDeploymentProtection: map{passwordProtection: map?{deploymentType: str}, ssoProtection: map?{deploymentType: str}}, defaultExpirationSettings: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, defaultPassport: map?{connectorId: str, deploymentType: str}, defaultProjectJobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, defaultRoles: map{teamPermissions: [str], teamRoles: [str]}, deploymentPolicy: map{deploymentSources: [map], gitSources: [map]}, deploymentStorageRollout: map{cohort: str, meteredAt: num, meterReason: str, retentionAppliedAt: num, retentionOptOutAt: num}, description: str?, disableHardAutoBlocks: any, disableRepositoryDispatchEvents: bool, disjunctiveProductionSecretPolicy: str?, dpAccessRequestsMode: str, emailDomain: str?, enablePreviewFeedback: str?, enableProductionFeedback: str?, hideIpAddresses: bool?, hideIpAddressesInLogDrains: bool?, id: str, integrationTokensInvalidatedAt: num, inviteCode: str, ipBuckets: [map], membership: map{accessRequestedAt: num, confirmed: bool, created: num, createdAt: num, entitlements: [map], joinedFrom: map{commitId: str, dsyncConnectedAt: num, dsyncUserId: str, gitUserId: any, gitUserLogin: str, idpUserId: str, origin: str, repoId: str, repoPath: str, ssoConnectedAt: num, ssoUserId: str}, role: str, teamId: str, teamPermissions: [str], teamRoles: [str], uid: str}, name: str?, nsnbConfig: map{preference: str}, orgRootTeamId: str, parentId: str, personalAccessTokensInvalidatedAt: num, platform: bool, previewDeploymentSuffix: str?, remoteCaching: map{enabled: bool}, requireVerifiedCommits: bool, resourceConfig: map{blobStores: num, buildEntitlements: map{enhancedBuilds: bool}, buildMachine: map{default: str}, concurrentBuilds: num, customEnvironmentsPerProject: num, edgeConfigs: num, edgeConfigSize: num, elasticConcurrencyEnabled: bool, kvDatabases: num, postgresDatabases: num, serverlessFunctionMaxMemorySize: num}, saml: map{connection: map{connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, state: str, syncState: str, type: str, status: str}, defaultRedirectUri: str, directory: map{connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, state: str, syncState: str, type: str}, enforced: bool, roles: map}, sensitiveEnvironmentVariablePolicy: str?, slug: str, stagingPrefix: str, strictConnectors: map{enabled: bool, updatedAt: num}, strictDeploymentProtectionSettings: map{enabled: bool, updatedAt: num}, strictPasswordProtectionSettings: map{enabled: bool, updatedAt: num}, strictShareableLinks: map{enabled: bool, updatedAt: num}, updatedAt: num}
@errors {400, 401, 403, 404, 410}

@endpoint PATCH /v2/teams/{teamId}
@required {teamId: str}
@optional {slug: str, avatar: str, 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, disjunctiveProductionSecretPolicy: str, remoteCaching: map{enabled: bool}, hideIpAddresses: bool, hideIpAddressesInLogDrains: bool, dpAccessRequestsMode: str(all/none/email-domain), requireVerifiedCommits: bool, disableRepositoryDispatchEvents: bool, defaultDeploymentProtection: map{passwordProtection: map, ssoProtection: map}, defaultPassport: map{connectorId!: str, deploymentType: str}, defaultExpirationSettings: map{expiration: str, expirationProduction: str, expirationCanceled: str, expirationErrored: str}, deploymentPolicy: any, strictDeploymentProtectionSettings: map{enabled!: bool}, strictShareableLinks: map{enabled!: bool}, strictPasswordProtectionSettings: map{enabled!: bool}, strictConnectors: map{enabled!: bool}, nsnbConfig: any, defaultProjectJobs: any, resourceConfig: map{buildMachine: map}}
@returns(200) {apiKeysInvalidatedAt: num, appTokensInvalidatedAt: num, avatar: str?, billing: map?{plan: str}, connect: map{enabled: bool}, createdAt: num, creatorId: str, defaultDeploymentProtection: map{passwordProtection: map?{deploymentType: str}, ssoProtection: map?{deploymentType: str}}, defaultExpirationSettings: map{deploymentsToKeep: num, expirationDays: num, expirationDaysCanceled: num, expirationDaysErrored: num, expirationDaysProduction: num}, defaultPassport: map?{connectorId: str, deploymentType: str}, defaultProjectJobs: map{lint: map{targets: [str]}, mfe-config-present: map{targets: [str]}, typecheck: map{targets: [str]}}, defaultRoles: map{teamPermissions: [str], teamRoles: [str]}, deploymentPolicy: map{deploymentSources: [map], gitSources: [map]}, deploymentStorageRollout: map{cohort: str, meteredAt: num, meterReason: str, retentionAppliedAt: num, retentionOptOutAt: num}, description: str?, disableHardAutoBlocks: any, disableRepositoryDispatchEvents: bool, disjunctiveProductionSecretPolicy: str?, dpAccessRequestsMode: str, emailDomain: str?, enablePreviewFeedback: str?, enableProductionFeedback: str?, hideIpAddresses: bool?, hideIpAddressesInLogDrains: bool?, id: str, integrationTokensInvalidatedAt: num, inviteCode: str, ipBuckets: [map], membership: map{accessRequestedAt: num, confirmed: bool, created: num, createdAt: num, entitlements: [map], joinedFrom: map{commitId: str, dsyncConnectedAt: num, dsyncUserId: str, gitUserId: any, gitUserLogin: str, idpUserId: str, origin: str, repoId: str, repoPath: str, ssoConnectedAt: num, ssoUserId: str}, role: str, teamId: str, teamPermissions: [str], teamRoles: [str], uid: str}, name: str?, nsnbConfig: map{preference: str}, orgRootTeamId: str, parentId: str, personalAccessTokensInvalidatedAt: num, platform: bool, previewDeploymentSuffix: str?, remoteCaching: map{enabled: bool}, requireVerifiedCommits: bool, resourceConfig: map{blobStores: num, buildEntitlements: map{enhancedBuilds: bool}, buildMachine: map{default: str}, concurrentBuilds: num, customEnvironmentsPerProject: num, edgeConfigs: num, edgeConfigSize: num, elasticConcurrencyEnabled: bool, kvDatabases: num, postgresDatabases: num, serverlessFunctionMaxMemorySize: num}, saml: map{connection: map{connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, state: str, syncState: str, type: str, status: str}, defaultRedirectUri: str, directory: map{connectedAt: num, lastReceivedWebhookEvent: num, lastSyncedAt: num, state: str, syncState: str, type: str}, enforced: bool, roles: map}, sensitiveEnvironmentVariablePolicy: str?, slug: str, stagingPrefix: str, strictConnectors: map{enabled: bool, updatedAt: num}, strictDeploymentProtectionSettings: map{enabled: bool, updatedAt: num}, strictPasswordProtectionSettings: map{enabled: bool, updatedAt: num}, strictShareableLinks: map{enabled: bool, updatedAt: num}, updatedAt: num}
@errors {400, 401, 402, 403, 409, 410, 428}

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

@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, 404, 409, 410}

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

@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, 410, 503}

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

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

@endpoint DELETE /v1/teams/{teamId}/microfrontends/{groupId}
@required {groupId: str, teamId: str}
@optional {slug: str}
@returns(200)
@errors {400, 401, 403, 404, 410, 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, 410, 426}

@endgroup

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

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

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

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

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

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

@endgroup

@group vcr
@endpoint POST /v1/vcr/repository
@required {projectId: str, name: str}
@optional {teamId: str, slug: str}
@returns(200) {repository: map{createdAt: str, id: str, name: str, projectId: str, public: bool, updatedAt: str}}
@errors {400, 401, 402, 403, 404, 409, 410}

@endpoint GET /v1/vcr/repository
@required {projectId: str}
@optional {limit: int, cursor: str, teamId: str, slug: str}
@returns(200) {nextCursor: str, repositories: [map]}
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}
@required {projectId: str, idOrName: str}
@optional {teamId: str, slug: str}
@returns(200) {repository: map{createdAt: str, id: str, name: str, projectId: str, public: bool, updatedAt: str}}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/vcr/repository/{idOrName}
@required {projectId: str, idOrName: str}
@optional {teamId: str, slug: str}
@returns(202)
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}/images
@required {projectId: str, idOrName: str}
@optional {limit: int, cursor: str, untagged: bool, teamId: str, slug: str}
@returns(200) {images: [map], nextCursor: str}
@errors {400, 401, 403, 404, 410}

@endpoint POST /v1/vcr/repository/{idOrName}/permissions
@required {projectId: str, idOrName: str}
@optional {teamId: str, slug: str, teamId: str, teamSlug: str}
@returns(200) {permission: map{createdAt: str, repositoryId: str, teamId: str, teamSlug: str}}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/vcr/repository/{idOrName}/permissions
@required {projectId: str, idOrName: str}
@optional {teamId: str, slug: str, teamId: str, teamSlug: str}
@returns(204)
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}/permissions
@required {projectId: str, idOrName: str}
@optional {limit: int, cursor: str, teamId: str, slug: str}
@returns(200) {nextCursor: str, permissions: [map]}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/vcr/repository/{idOrName}/permissions/all
@required {projectId: str, idOrName: str}
@optional {teamId: str, slug: str}
@returns(204)
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}/tags
@required {projectId: str, idOrName: str}
@optional {limit: int, cursor: str, sortBy: str(updatedAt/tag)=updatedAt, sortOrder: str(asc/desc)=desc, teamId: str, slug: str}
@returns(200) {nextCursor: str, tags: [map]}
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}/tags/{tag}
@required {projectId: str, idOrName: str, tag: str}
@optional {teamId: str, slug: str}
@returns(200) {tag: map{arch: str, createdAt: str, imageId: str, kind: str, manifestDigest: str, platform: str, pushedBy: str, sizeInBytes: num, status: str?, tag: str, updatedAt: str}}
@errors {400, 401, 403, 404, 410}

@endpoint GET /v1/vcr/repository/{idOrName}/images/{imageIdOrDigest}
@required {projectId: str, idOrName: str, imageIdOrDigest: str}
@optional {teamId: str, slug: str}
@returns(200) {image: map{arch: str, createdAt: str, id: str, kind: str, layers: [any], manifestDigest: str, platform: str, pushedBy: str, repositoryId: str, sizeInBytes: num, status: str?, tags: [str]}}
@errors {400, 401, 403, 404, 410}

@endpoint DELETE /v1/vcr/repository/{idOrName}/images/{imageId}
@required {projectId: str, idOrName: str, imageId: str}
@optional {teamId: str, slug: str}
@returns(202)
@errors {400, 401, 403, 404, 410}

@endgroup

@group v2
@endpoint GET /v2/
@returns(200)
@errors {400, 401, 402, 403, 404, 410}

@endgroup

@group {teamSlug}
@endpoint HEAD /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/{digest}
@required {teamSlug: str, projectSlug: str, repositoryName: str, digest: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 410}

@endpoint GET /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/{digest}
@required {teamSlug: str, projectSlug: str, repositoryName: str, digest: str}
@errors {400, 401, 402, 403, 404, 410, 416}

@endpoint DELETE /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/{digest}
@required {teamSlug: str, projectSlug: str, repositoryName: str, digest: str}
@errors {400, 401, 402, 403, 404, 405, 410}

@endpoint GET /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/uploads/{uuid}
@required {teamSlug: str, projectSlug: str, repositoryName: str, uuid: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 410}

@endpoint DELETE /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/uploads/{uuid}
@required {teamSlug: str, projectSlug: str, repositoryName: str, uuid: str}
@returns(204)
@errors {400, 401, 402, 403, 404, 410}

@endpoint PATCH /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/uploads/{uuid}
@required {teamSlug: str, projectSlug: str, repositoryName: str, uuid: str}
@returns(202)
@errors {400, 401, 402, 403, 404, 410, 413}

@endpoint PUT /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/uploads/{uuid}
@required {teamSlug: str, projectSlug: str, repositoryName: str, uuid: str, digest: str}
@returns(201)
@errors {400, 401, 402, 403, 404, 410, 413}

@endpoint POST /v2/{teamSlug}/{projectSlug}/{repositoryName}/blobs/uploads/
@required {teamSlug: str, projectSlug: str, repositoryName: str}
@optional {mount: str, from: str}
@returns(202)
@errors {400, 401, 402, 403, 404, 410}

@endpoint PUT /v2/{teamSlug}/{projectSlug}/{repositoryName}/manifests/{reference}
@required {teamSlug: str, projectSlug: str, repositoryName: str, reference: str}
@returns(201)
@errors {400, 401, 402, 403, 404, 410, 413}

@endpoint HEAD /v2/{teamSlug}/{projectSlug}/{repositoryName}/manifests/{reference}
@required {teamSlug: str, projectSlug: str, repositoryName: str, reference: str}
@returns(200)
@errors {400, 401, 402, 403, 404, 410}

@endpoint GET /v2/{teamSlug}/{projectSlug}/{repositoryName}/manifests/{reference}
@required {teamSlug: str, projectSlug: str, repositoryName: str, reference: str}
@errors {400, 401, 402, 403, 404, 410}

@endpoint DELETE /v2/{teamSlug}/{projectSlug}/{repositoryName}/manifests/{reference}
@required {teamSlug: str, projectSlug: str, repositoryName: str, reference: str}
@returns(202)
@errors {400, 401, 402, 403, 404, 410}

@endpoint GET /v2/{teamSlug}/{projectSlug}/{repositoryName}/tags/list
@required {teamSlug: str, projectSlug: str, repositoryName: str}
@optional {n: int, last: str}
@returns(200) {name: str, tags: [str]}
@errors {400, 401, 402, 403, 404, 410}

@endgroup

@group web
@endpoint POST /web/insights/toggle
@required {projectId: str, value: bool}
@returns(200) {value: bool}
@errors {400, 401, 403, 410}

@endgroup

@group query
@endpoint GET /v1/query/web-analytics/visits/aggregate
@required {projectId: str, by: [str], since: any, until: any}
@optional {limit: int=10, filter: str, teamId: str, slug: str}
@returns(200) {data: any, query: map{filter: str, groupBy: [any], limit: num, since: str, until: str}, version: num}
@errors {400, 401, 402, 403, 404, 410, 503}

@endpoint GET /v1/query/web-analytics/events/aggregate
@required {projectId: str, by: [str], since: any, until: any}
@optional {limit: int=10, filter: str, teamId: str, slug: str}
@returns(200) {data: any, query: map{filter: str, groupBy: [any], limit: num, since: str, until: str}, version: num}
@errors {400, 401, 402, 403, 404, 410, 503}

@endpoint GET /v1/query/web-analytics/visits/count
@required {projectId: str}
@optional {since: any, until: any, filter: str, teamId: str, slug: str}
@returns(200) {data: any, query: map{filter: str, since: str, until: str}, version: num}
@errors {400, 401, 402, 403, 404, 410, 503}

@endpoint GET /v1/query/web-analytics/events/count
@required {projectId: str}
@optional {since: any, until: any, filter: str, teamId: str, slug: str}
@returns(200) {data: any, query: map{filter: str, since: str, until: str}, version: num}
@errors {400, 401, 402, 403, 404, 410, 503}

@endgroup

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

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

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

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

@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, 410}

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

@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, 410}

@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{email: str, uid: str, username: str}, deletedAt: num?, deployment: map{id: str, meta: str, url: str}, deploymentId: str?, microfrontends: map{applications: any, defaultApp: map{projectId: str}}, projectId: str?, protectionBypass: map, redirect: str?, redirectStatusCode: num?, uid: str, updatedAt: num?}
@errors {400, 401, 403, 404, 410}

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

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

@endgroup

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

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

@endpoint GET /v8/certs
@optional {teamId: str, slug: str}
@returns(200) {certs: [map], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 410}

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

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

@endgroup

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

@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 /v7/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) {deployments: [map], pagination: map{count: num, next: num?, prev: num?}}
@errors {400, 401, 403, 404, 410, 422}

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

@endgroup

@end