@distilled.cloud/vercel 0.0.0 → 1.0.0-rc.5

package/lib/services/rolling_release.d.ts

@@ -0,0 +1,764 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type VercelOpError, type VercelOpContext } from "../protocol.ts";
+export type { VercelOpError, VercelOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export interface ApproveRollingReleaseStageRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The index of the stage to transition to */
+    nextStageIndex: number;
+    /** The id of the canary deployment to approve for the next stage */
+    canaryDeploymentId: string;
+}
+export declare const ApproveRollingReleaseStageRequest: S.Schema<ApproveRollingReleaseStageRequest>;
+/** The current state of the rolling release */
+export type ApproveRollingReleaseStageResponseRollingReleaseState = "ABORTED" | "ACTIVE" | "COMPLETE";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseState: any;
+/** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+export type ApproveRollingReleaseStageResponseRollingReleaseSubstate = "PAUSED";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseSubstate: any;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentTarget = "production" | "staging";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentSource: any;
+/** The current deployment receiving production traffic */
+export interface ApproveRollingReleaseStageResponseRollingReleaseCurrentDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: ApproveRollingReleaseStageResponseRollingReleaseCurrentDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCurrentDeployment: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseCurrentDeployment>;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentTarget = "production" | "staging";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentSource: any;
+/** The canary deployment being rolled out */
+export interface ApproveRollingReleaseStageResponseRollingReleaseCanaryDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: ApproveRollingReleaseStageResponseRollingReleaseCanaryDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const ApproveRollingReleaseStageResponseRollingReleaseCanaryDeployment: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseCanaryDeployment>;
+/** The advancement type of the rolling release */
+export type ApproveRollingReleaseStageResponseRollingReleaseAdvancementType = "automatic" | "manual-approval";
+export declare const ApproveRollingReleaseStageResponseRollingReleaseAdvancementType: any;
+/** All stages configured for this rolling release */
+export interface ApproveRollingReleaseStageResponseRollingReleaseStagesItem {
+    /** The zero-based index of the stage */
+    index: number;
+    /** Whether or not this stage is the final stage (targetPercentage === 100) */
+    isFinalStage: boolean;
+    /** The percentage of traffic to serve to the canary deployment (0-100) */
+    targetPercentage: number;
+    /** Whether or not this stage requires manual approval to proceed */
+    requireApproval: boolean;
+    /** Duration in seconds for automatic advancement, null for manual stages or the final stage */
+    duration: number | null;
+    /** Whether to linearly shift traffic over the duration of this stage */
+    linearShift?: boolean;
+}
+export declare const ApproveRollingReleaseStageResponseRollingReleaseStagesItem: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** All stages configured for this rolling release */
+export type ApproveRollingReleaseStageResponseRollingReleaseStagesList = Array<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+export declare const ApproveRollingReleaseStageResponseRollingReleaseStagesList: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesList>;
+/** The currently active stage, null if the rollout is aborted */
+export type ApproveRollingReleaseStageResponseRollingReleaseActiveStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const ApproveRollingReleaseStageResponseRollingReleaseActiveStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** The next stage to be activated, null if not in ACTIVE state */
+export type ApproveRollingReleaseStageResponseRollingReleaseNextStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const ApproveRollingReleaseStageResponseRollingReleaseNextStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** Rolling release information including configuration and document details, or null if no rolling release exists */
+export interface ApproveRollingReleaseStageResponseRollingRelease {
+    /** The current state of the rolling release */
+    state: ApproveRollingReleaseStageResponseRollingReleaseState;
+    /** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+    substate: ApproveRollingReleaseStageResponseRollingReleaseSubstate | null;
+    /** The current deployment receiving production traffic */
+    currentDeployment: ApproveRollingReleaseStageResponseRollingReleaseCurrentDeployment | null;
+    /** The canary deployment being rolled out */
+    canaryDeployment: ApproveRollingReleaseStageResponseRollingReleaseCanaryDeployment | null;
+    /** The ID of a deployment queued for the next rolling release */
+    queuedDeploymentId: string | null;
+    /** The advancement type of the rolling release */
+    advancementType: ApproveRollingReleaseStageResponseRollingReleaseAdvancementType;
+    /** All stages configured for this rolling release */
+    stages: ApproveRollingReleaseStageResponseRollingReleaseStagesList;
+    /** The currently active stage, null if the rollout is aborted */
+    activeStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** The next stage to be activated, null if not in ACTIVE state */
+    nextStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** Unix timestamp in milliseconds when the rolling release started */
+    startedAt: number;
+    /** Unix timestamp in milliseconds when the rolling release was last updated */
+    updatedAt: number;
+    /** When set (for example while {@link substate} is `PAUSED`), the canary traffic percentage persisted on the rollout document — use for dashboard display when linear shift is active. */
+    currentCanaryPercentage?: number;
+}
+export declare const ApproveRollingReleaseStageResponseRollingRelease: S.Schema<ApproveRollingReleaseStageResponseRollingRelease>;
+export interface ApproveRollingReleaseStageResponse {
+    /** Rolling release information including configuration and document details, or null if no rolling release exists */
+    rollingRelease: ApproveRollingReleaseStageResponseRollingRelease | null;
+}
+export declare const ApproveRollingReleaseStageResponse: S.Schema<ApproveRollingReleaseStageResponse>;
+export interface CompleteRollingReleaseRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The ID of the canary deployment to complete */
+    canaryDeploymentId: string;
+}
+export declare const CompleteRollingReleaseRequest: S.Schema<CompleteRollingReleaseRequest>;
+/** The current state of the rolling release */
+export type CompleteRollingReleaseResponseRollingReleaseState = "ABORTED" | "ACTIVE" | "COMPLETE";
+export declare const CompleteRollingReleaseResponseRollingReleaseState: any;
+/** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+export type CompleteRollingReleaseResponseRollingReleaseSubstate = "PAUSED";
+export declare const CompleteRollingReleaseResponseRollingReleaseSubstate: any;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentTarget = "production" | "staging";
+export declare const CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentSource: any;
+/** The current deployment receiving production traffic */
+export interface CompleteRollingReleaseResponseRollingReleaseCurrentDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: CompleteRollingReleaseResponseRollingReleaseCurrentDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const CompleteRollingReleaseResponseRollingReleaseCurrentDeployment: S.Schema<CompleteRollingReleaseResponseRollingReleaseCurrentDeployment>;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentTarget = "production" | "staging";
+export declare const CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentSource: any;
+/** The canary deployment being rolled out */
+export interface CompleteRollingReleaseResponseRollingReleaseCanaryDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: CompleteRollingReleaseResponseRollingReleaseCanaryDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const CompleteRollingReleaseResponseRollingReleaseCanaryDeployment: S.Schema<CompleteRollingReleaseResponseRollingReleaseCanaryDeployment>;
+/** The advancement type of the rolling release */
+export type CompleteRollingReleaseResponseRollingReleaseAdvancementType = "automatic" | "manual-approval";
+export declare const CompleteRollingReleaseResponseRollingReleaseAdvancementType: any;
+/** All stages configured for this rolling release */
+export type CompleteRollingReleaseResponseRollingReleaseStagesItem = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const CompleteRollingReleaseResponseRollingReleaseStagesItem: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** All stages configured for this rolling release */
+export type CompleteRollingReleaseResponseRollingReleaseStagesList = Array<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+export declare const CompleteRollingReleaseResponseRollingReleaseStagesList: S.Schema<CompleteRollingReleaseResponseRollingReleaseStagesList>;
+/** The currently active stage, null if the rollout is aborted */
+export type CompleteRollingReleaseResponseRollingReleaseActiveStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const CompleteRollingReleaseResponseRollingReleaseActiveStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** The next stage to be activated, null if not in ACTIVE state */
+export type CompleteRollingReleaseResponseRollingReleaseNextStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const CompleteRollingReleaseResponseRollingReleaseNextStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** Rolling release information including configuration and document details, or null if no rolling release exists */
+export interface CompleteRollingReleaseResponseRollingRelease {
+    /** The current state of the rolling release */
+    state: CompleteRollingReleaseResponseRollingReleaseState;
+    /** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+    substate: CompleteRollingReleaseResponseRollingReleaseSubstate | null;
+    /** The current deployment receiving production traffic */
+    currentDeployment: CompleteRollingReleaseResponseRollingReleaseCurrentDeployment | null;
+    /** The canary deployment being rolled out */
+    canaryDeployment: CompleteRollingReleaseResponseRollingReleaseCanaryDeployment | null;
+    /** The ID of a deployment queued for the next rolling release */
+    queuedDeploymentId: string | null;
+    /** The advancement type of the rolling release */
+    advancementType: CompleteRollingReleaseResponseRollingReleaseAdvancementType;
+    /** All stages configured for this rolling release */
+    stages: CompleteRollingReleaseResponseRollingReleaseStagesList;
+    /** The currently active stage, null if the rollout is aborted */
+    activeStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** The next stage to be activated, null if not in ACTIVE state */
+    nextStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** Unix timestamp in milliseconds when the rolling release started */
+    startedAt: number;
+    /** Unix timestamp in milliseconds when the rolling release was last updated */
+    updatedAt: number;
+    /** When set (for example while {@link substate} is `PAUSED`), the canary traffic percentage persisted on the rollout document — use for dashboard display when linear shift is active. */
+    currentCanaryPercentage?: number;
+}
+export declare const CompleteRollingReleaseResponseRollingRelease: S.Schema<CompleteRollingReleaseResponseRollingRelease>;
+export interface CompleteRollingReleaseResponse {
+    /** Rolling release information including configuration and document details, or null if no rolling release exists */
+    rollingRelease: CompleteRollingReleaseResponseRollingRelease | null;
+}
+export declare const CompleteRollingReleaseResponse: S.Schema<CompleteRollingReleaseResponse>;
+export interface DeleteRollingReleaseConfigRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteRollingReleaseConfigRequest: S.Schema<DeleteRollingReleaseConfigRequest>;
+export interface DeleteRollingReleaseConfigResponse {
+    rollingRelease: unknown | null;
+}
+export declare const DeleteRollingReleaseConfigResponse: S.Schema<DeleteRollingReleaseConfigResponse>;
+/** Filter by rolling release state */
+export type GetRollingReleaseRequestState = "ACTIVE" | "COMPLETE" | "ABORTED";
+export declare const GetRollingReleaseRequestState: any;
+export interface GetRollingReleaseRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** Filter by rolling release state */
+    state?: GetRollingReleaseRequestState | (string & {});
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetRollingReleaseRequest: S.Schema<GetRollingReleaseRequest>;
+/** The current state of the rolling release */
+export type GetRollingReleaseResponseRollingReleaseState = "ABORTED" | "ACTIVE" | "COMPLETE";
+export declare const GetRollingReleaseResponseRollingReleaseState: any;
+/** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+export type GetRollingReleaseResponseRollingReleaseSubstate = "PAUSED";
+export declare const GetRollingReleaseResponseRollingReleaseSubstate: any;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type GetRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const GetRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type GetRollingReleaseResponseRollingReleaseCurrentDeploymentTarget = "production" | "staging";
+export declare const GetRollingReleaseResponseRollingReleaseCurrentDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type GetRollingReleaseResponseRollingReleaseCurrentDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const GetRollingReleaseResponseRollingReleaseCurrentDeploymentSource: any;
+/** The current deployment receiving production traffic */
+export interface GetRollingReleaseResponseRollingReleaseCurrentDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: GetRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: GetRollingReleaseResponseRollingReleaseCurrentDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: GetRollingReleaseResponseRollingReleaseCurrentDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const GetRollingReleaseResponseRollingReleaseCurrentDeployment: S.Schema<GetRollingReleaseResponseRollingReleaseCurrentDeployment>;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type GetRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const GetRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type GetRollingReleaseResponseRollingReleaseCanaryDeploymentTarget = "production" | "staging";
+export declare const GetRollingReleaseResponseRollingReleaseCanaryDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type GetRollingReleaseResponseRollingReleaseCanaryDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const GetRollingReleaseResponseRollingReleaseCanaryDeploymentSource: any;
+/** The canary deployment being rolled out */
+export interface GetRollingReleaseResponseRollingReleaseCanaryDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: GetRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: GetRollingReleaseResponseRollingReleaseCanaryDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: GetRollingReleaseResponseRollingReleaseCanaryDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const GetRollingReleaseResponseRollingReleaseCanaryDeployment: S.Schema<GetRollingReleaseResponseRollingReleaseCanaryDeployment>;
+/** The advancement type of the rolling release */
+export type GetRollingReleaseResponseRollingReleaseAdvancementType = "automatic" | "manual-approval";
+export declare const GetRollingReleaseResponseRollingReleaseAdvancementType: any;
+/** All stages configured for this rolling release */
+export type GetRollingReleaseResponseRollingReleaseStagesItem = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const GetRollingReleaseResponseRollingReleaseStagesItem: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** All stages configured for this rolling release */
+export type GetRollingReleaseResponseRollingReleaseStagesList = Array<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+export declare const GetRollingReleaseResponseRollingReleaseStagesList: S.Schema<GetRollingReleaseResponseRollingReleaseStagesList>;
+/** The currently active stage, null if the rollout is aborted */
+export type GetRollingReleaseResponseRollingReleaseActiveStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const GetRollingReleaseResponseRollingReleaseActiveStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** The next stage to be activated, null if not in ACTIVE state */
+export type GetRollingReleaseResponseRollingReleaseNextStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const GetRollingReleaseResponseRollingReleaseNextStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** Rolling release information including configuration and document details, or null if no rolling release exists */
+export interface GetRollingReleaseResponseRollingRelease {
+    /** The current state of the rolling release */
+    state: GetRollingReleaseResponseRollingReleaseState;
+    /** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+    substate: GetRollingReleaseResponseRollingReleaseSubstate | null;
+    /** The current deployment receiving production traffic */
+    currentDeployment: GetRollingReleaseResponseRollingReleaseCurrentDeployment | null;
+    /** The canary deployment being rolled out */
+    canaryDeployment: GetRollingReleaseResponseRollingReleaseCanaryDeployment | null;
+    /** The ID of a deployment queued for the next rolling release */
+    queuedDeploymentId: string | null;
+    /** The advancement type of the rolling release */
+    advancementType: GetRollingReleaseResponseRollingReleaseAdvancementType;
+    /** All stages configured for this rolling release */
+    stages: GetRollingReleaseResponseRollingReleaseStagesList;
+    /** The currently active stage, null if the rollout is aborted */
+    activeStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** The next stage to be activated, null if not in ACTIVE state */
+    nextStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** Unix timestamp in milliseconds when the rolling release started */
+    startedAt: number;
+    /** Unix timestamp in milliseconds when the rolling release was last updated */
+    updatedAt: number;
+    /** When set (for example while {@link substate} is `PAUSED`), the canary traffic percentage persisted on the rollout document — use for dashboard display when linear shift is active. */
+    currentCanaryPercentage?: number;
+}
+export declare const GetRollingReleaseResponseRollingRelease: S.Schema<GetRollingReleaseResponseRollingRelease>;
+export interface GetRollingReleaseResponse {
+    /** Rolling release information including configuration and document details, or null if no rolling release exists */
+    rollingRelease: GetRollingReleaseResponseRollingRelease | null;
+}
+export declare const GetRollingReleaseResponse: S.Schema<GetRollingReleaseResponse>;
+export interface GetRollingReleaseBillingStatusRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetRollingReleaseBillingStatusRequest: S.Schema<GetRollingReleaseBillingStatusRequest>;
+export type GetRollingReleaseBillingStatusResponseBodyCase0AvailableSlots = 0;
+export declare const GetRollingReleaseBillingStatusResponseBodyCase0AvailableSlots: any;
+export type GetRollingReleaseBillingStatusResponseBodyCase0Reason = "plan_not_supported";
+export declare const GetRollingReleaseBillingStatusResponseBodyCase0Reason: any;
+export interface GetRollingReleaseBillingStatusResponseBodyCase0 {
+    availableSlots: GetRollingReleaseBillingStatusResponseBodyCase0AvailableSlots;
+    reason: GetRollingReleaseBillingStatusResponseBodyCase0Reason;
+    message: string;
+}
+export declare const GetRollingReleaseBillingStatusResponseBodyCase0: S.Schema<GetRollingReleaseBillingStatusResponseBodyCase0>;
+export type GetRollingReleaseBillingStatusResponseBodyCase1AvailableSlots = "unlimited";
+export declare const GetRollingReleaseBillingStatusResponseBodyCase1AvailableSlots: any;
+export type GetRollingReleaseBillingStatusResponseBodyCase1Reason = "unlimited_slots";
+export declare const GetRollingReleaseBillingStatusResponseBodyCase1Reason: any;
+export interface GetRollingReleaseBillingStatusResponseBodyCase1 {
+    availableSlots: GetRollingReleaseBillingStatusResponseBodyCase1AvailableSlots;
+    reason: GetRollingReleaseBillingStatusResponseBodyCase1Reason;
+    message: string;
+}
+export declare const GetRollingReleaseBillingStatusResponseBodyCase1: S.Schema<GetRollingReleaseBillingStatusResponseBodyCase1>;
+export type GetRollingReleaseBillingStatusResponseBodyCase2AvailableSlots = 0;
+export declare const GetRollingReleaseBillingStatusResponseBodyCase2AvailableSlots: any;
+export type GetRollingReleaseBillingStatusResponseBodyCase2Reason = "no_available_slots";
+export declare const GetRollingReleaseBillingStatusResponseBodyCase2Reason: any;
+export type GetRollingReleaseBillingStatusResponseBodyCase2EnabledProjectsList = Array<string>;
+export declare const GetRollingReleaseBillingStatusResponseBodyCase2EnabledProjectsList: S.Schema<GetRollingReleaseBillingStatusResponseBodyCase2EnabledProjectsList>;
+export interface GetRollingReleaseBillingStatusResponseBodyCase2 {
+    availableSlots: GetRollingReleaseBillingStatusResponseBodyCase2AvailableSlots;
+    reason: GetRollingReleaseBillingStatusResponseBodyCase2Reason;
+    message: string;
+    enabledProjects: GetRollingReleaseBillingStatusResponseBodyCase2EnabledProjectsList;
+}
+export declare const GetRollingReleaseBillingStatusResponseBodyCase2: S.Schema<GetRollingReleaseBillingStatusResponseBodyCase2>;
+export type GetRollingReleaseBillingStatusResponseBodyCase3Reason = "available_slots";
+export declare const GetRollingReleaseBillingStatusResponseBodyCase3Reason: any;
+export interface GetRollingReleaseBillingStatusResponseBodyCase3 {
+    availableSlots: number;
+    reason: GetRollingReleaseBillingStatusResponseBodyCase3Reason;
+    message: string;
+}
+export declare const GetRollingReleaseBillingStatusResponseBodyCase3: S.Schema<GetRollingReleaseBillingStatusResponseBodyCase3>;
+export type GetRollingReleaseBillingStatusResponseBody = GetRollingReleaseBillingStatusResponseBodyCase0 | GetRollingReleaseBillingStatusResponseBodyCase1 | GetRollingReleaseBillingStatusResponseBodyCase2 | GetRollingReleaseBillingStatusResponseBodyCase3;
+export declare const GetRollingReleaseBillingStatusResponseBody: S.Schema<GetRollingReleaseBillingStatusResponseBody>;
+export type GetRollingReleaseBillingStatusResponse = GetRollingReleaseBillingStatusResponseBody;
+export declare const GetRollingReleaseBillingStatusResponse: S.Schema<GetRollingReleaseBillingStatusResponse>;
+export interface GetRollingReleaseConfigRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetRollingReleaseConfigRequest: S.Schema<GetRollingReleaseConfigRequest>;
+/** An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100. */
+export interface GetRollingReleaseConfigResponseRollingReleaseStagesItem {
+    /** The percentage of traffic to serve to the canary deployment (0-100) */
+    targetPercentage: number;
+    /** Whether or not this stage requires manual approval to proceed */
+    requireApproval?: boolean;
+    /** Duration in minutes for automatic advancement to the next stage */
+    duration?: number;
+    /** Whether to linearly shift traffic over the duration of this stage */
+    linearShift?: boolean;
+}
+export declare const GetRollingReleaseConfigResponseRollingReleaseStagesItem: S.Schema<GetRollingReleaseConfigResponseRollingReleaseStagesItem>;
+/** An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100. */
+export type GetRollingReleaseConfigResponseRollingReleaseStagesList = Array<GetRollingReleaseConfigResponseRollingReleaseStagesItem>;
+export declare const GetRollingReleaseConfigResponseRollingReleaseStagesList: S.Schema<GetRollingReleaseConfigResponseRollingReleaseStagesList>;
+/** The metric this check evaluates. */
+export type GetRollingReleaseConfigResponseRollingReleaseGateChecksItemType = "error-rate-5xx";
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateChecksItemType: any;
+/** Response status codes to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Defaults to `[]` when omitted. */
+export type GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludeStatusCodesList = Array<number>;
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludeStatusCodesList: S.Schema<GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludeStatusCodesList>;
+/** Request paths to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Defaults to `[]` when omitted. */
+export type GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludePathsList = Array<string>;
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludePathsList: S.Schema<GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludePathsList>;
+/** The checks to evaluate. An empty array means nothing is evaluated. */
+export interface GetRollingReleaseConfigResponseRollingReleaseGateChecksItem {
+    /** The metric this check evaluates. */
+    type: GetRollingReleaseConfigResponseRollingReleaseGateChecksItemType;
+    /** Minimum number of requests required in the window before the check can fail. Below this, the check is inconclusive rather than failing, so low-traffic stages don't gate on noise. Defaults to `100` when omitted. */
+    minSampleSize?: number;
+    /** Response status codes to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Defaults to `[]` when omitted. */
+    excludeStatusCodes?: GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludeStatusCodesList;
+    /** Request paths to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Defaults to `[]` when omitted. */
+    excludePaths?: GetRollingReleaseConfigResponseRollingReleaseGateChecksItemExcludePathsList;
+    /** Seconds of ingest lag to allow for: the query's upper bound is `now() - this value`, so the check never reads a window that is still filling. Defaults to `30` when omitted. */
+    ingestWatermarkSeconds?: number;
+}
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateChecksItem: S.Schema<GetRollingReleaseConfigResponseRollingReleaseGateChecksItem>;
+/** The checks to evaluate. An empty array means nothing is evaluated. */
+export type GetRollingReleaseConfigResponseRollingReleaseGateChecksList = Array<GetRollingReleaseConfigResponseRollingReleaseGateChecksItem>;
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateChecksList: S.Schema<GetRollingReleaseConfigResponseRollingReleaseGateChecksList>;
+/** What to do when the gate trips: pause the rollout, or roll it back. */
+export type GetRollingReleaseConfigResponseRollingReleaseGateAction = "pause" | "rollback";
+export declare const GetRollingReleaseConfigResponseRollingReleaseGateAction: any;
+/** Automated gating configuration. Omitted (the default) means no gating is configured, which is equivalent to `enabled: false`. */
+export interface GetRollingReleaseConfigResponseRollingReleaseGate {
+    /** Whether automated gating is enabled for this project's rollouts. */
+    enabled: boolean;
+    /** The checks to evaluate. An empty array means nothing is evaluated. */
+    checks: GetRollingReleaseConfigResponseRollingReleaseGateChecksList;
+    /** How many failing evaluations within {@link windowSize} trip the gate. Defaults to `3` when omitted. */
+    failureThreshold?: number;
+    /** How many of the most recent evaluations {@link failureThreshold} is counted against. Defaults to `5` when omitted. */
+    windowSize?: number;
+    /** What to do when the gate trips: pause the rollout, or roll it back. */
+    action: GetRollingReleaseConfigResponseRollingReleaseGateAction;
+    /** When true, a tripped gate is only reported — {@link action} is not taken. */
+    dryRun: boolean;
+}
+export declare const GetRollingReleaseConfigResponseRollingReleaseGate: S.Schema<GetRollingReleaseConfigResponseRollingReleaseGate>;
+/** Project-level rolling release configuration that defines how deployments should be gradually rolled out */
+export interface GetRollingReleaseConfigResponseRollingRelease {
+    /** The environment that the release targets, currently only supports production. Adding in case we want to configure with alias groups or custom environments. */
+    target: string;
+    /** An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100. */
+    stages?: GetRollingReleaseConfigResponseRollingReleaseStagesList | null;
+    /** Whether the request served by a canary deployment should return a header indicating a canary was served. Defaults to `false` when omitted. */
+    canaryResponseHeader?: boolean;
+    /** Automated gating configuration. Omitted (the default) means no gating is configured, which is equivalent to `enabled: false`. */
+    gate?: GetRollingReleaseConfigResponseRollingReleaseGate;
+}
+export declare const GetRollingReleaseConfigResponseRollingRelease: S.Schema<GetRollingReleaseConfigResponseRollingRelease>;
+export interface GetRollingReleaseConfigResponse {
+    /** Project-level rolling release configuration that defines how deployments should be gradually rolled out */
+    rollingRelease: GetRollingReleaseConfigResponseRollingRelease | null;
+}
+export declare const GetRollingReleaseConfigResponse: S.Schema<GetRollingReleaseConfigResponse>;
+export interface StartRollingReleaseRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The ID of the canary deployment to start the rolling release for */
+    canaryDeploymentId: string;
+}
+export declare const StartRollingReleaseRequest: S.Schema<StartRollingReleaseRequest>;
+/** The current state of the rolling release */
+export type StartRollingReleaseResponseRollingReleaseState = "ABORTED" | "ACTIVE" | "COMPLETE";
+export declare const StartRollingReleaseResponseRollingReleaseState: any;
+/** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+export type StartRollingReleaseResponseRollingReleaseSubstate = "PAUSED";
+export declare const StartRollingReleaseResponseRollingReleaseSubstate: any;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type StartRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const StartRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type StartRollingReleaseResponseRollingReleaseCurrentDeploymentTarget = "production" | "staging";
+export declare const StartRollingReleaseResponseRollingReleaseCurrentDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type StartRollingReleaseResponseRollingReleaseCurrentDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const StartRollingReleaseResponseRollingReleaseCurrentDeploymentSource: any;
+/** The current deployment receiving production traffic */
+export interface StartRollingReleaseResponseRollingReleaseCurrentDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: StartRollingReleaseResponseRollingReleaseCurrentDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: StartRollingReleaseResponseRollingReleaseCurrentDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: StartRollingReleaseResponseRollingReleaseCurrentDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const StartRollingReleaseResponseRollingReleaseCurrentDeployment: S.Schema<StartRollingReleaseResponseRollingReleaseCurrentDeployment>;
+/** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+export type StartRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState = "BLOCKED" | "BUILDING" | "CANCELED" | "ERROR" | "INITIALIZING" | "QUEUED" | "READY";
+export declare const StartRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState: any;
+/** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+export type StartRollingReleaseResponseRollingReleaseCanaryDeploymentTarget = "production" | "staging";
+export declare const StartRollingReleaseResponseRollingReleaseCanaryDeploymentTarget: any;
+/** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+export type StartRollingReleaseResponseRollingReleaseCanaryDeploymentSource = "api-trigger-git-deploy" | "cli" | "clone/repo" | "drop" | "git" | "git-deploy-hook" | "import" | "import/repo" | "redeploy" | "v0-web";
+export declare const StartRollingReleaseResponseRollingReleaseCanaryDeploymentSource: any;
+/** The canary deployment being rolled out */
+export interface StartRollingReleaseResponseRollingReleaseCanaryDeployment {
+    /** The name of the project associated with the deployment at the time that the deployment was created */
+    name: string;
+    /** A number containing the date when the deployment was created in milliseconds */
+    createdAt: number;
+    /** The state of the deployment depending on the process of deploying, or if it is ready or in an error state */
+    readyState: StartRollingReleaseResponseRollingReleaseCanaryDeploymentReadyState;
+    /** A string holding the unique ID of the deployment */
+    id: string;
+    /** If defined, either `staging` if a staging alias in the format `<project>.<team>.now.sh` was assigned upon creation, or `production` if the aliases from `alias` were assigned. `null` value indicates the "preview" deployment. */
+    target?: StartRollingReleaseResponseRollingReleaseCanaryDeploymentTarget | null;
+    readyStateAt?: number;
+    /** Where was the deployment created from. Best-effort guess for metrics only — not authoritative; do not gate behavior on it. */
+    source?: StartRollingReleaseResponseRollingReleaseCanaryDeploymentSource;
+    /** A string with the unique URL of the deployment */
+    url: string;
+}
+export declare const StartRollingReleaseResponseRollingReleaseCanaryDeployment: S.Schema<StartRollingReleaseResponseRollingReleaseCanaryDeployment>;
+/** The advancement type of the rolling release */
+export type StartRollingReleaseResponseRollingReleaseAdvancementType = "automatic" | "manual-approval";
+export declare const StartRollingReleaseResponseRollingReleaseAdvancementType: any;
+/** All stages configured for this rolling release */
+export type StartRollingReleaseResponseRollingReleaseStagesItem = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const StartRollingReleaseResponseRollingReleaseStagesItem: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** All stages configured for this rolling release */
+export type StartRollingReleaseResponseRollingReleaseStagesList = Array<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+export declare const StartRollingReleaseResponseRollingReleaseStagesList: S.Schema<StartRollingReleaseResponseRollingReleaseStagesList>;
+/** The currently active stage, null if the rollout is aborted */
+export type StartRollingReleaseResponseRollingReleaseActiveStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const StartRollingReleaseResponseRollingReleaseActiveStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** The next stage to be activated, null if not in ACTIVE state */
+export type StartRollingReleaseResponseRollingReleaseNextStage = ApproveRollingReleaseStageResponseRollingReleaseStagesItem;
+export declare const StartRollingReleaseResponseRollingReleaseNextStage: S.Schema<ApproveRollingReleaseStageResponseRollingReleaseStagesItem>;
+/** Rolling release information including configuration and document details, or null if no rolling release exists */
+export interface StartRollingReleaseResponseRollingRelease {
+    /** The current state of the rolling release */
+    state: StartRollingReleaseResponseRollingReleaseState;
+    /** When set to `PAUSED`, the rollout is frozen at the current percentage until continued. */
+    substate: StartRollingReleaseResponseRollingReleaseSubstate | null;
+    /** The current deployment receiving production traffic */
+    currentDeployment: StartRollingReleaseResponseRollingReleaseCurrentDeployment | null;
+    /** The canary deployment being rolled out */
+    canaryDeployment: StartRollingReleaseResponseRollingReleaseCanaryDeployment | null;
+    /** The ID of a deployment queued for the next rolling release */
+    queuedDeploymentId: string | null;
+    /** The advancement type of the rolling release */
+    advancementType: StartRollingReleaseResponseRollingReleaseAdvancementType;
+    /** All stages configured for this rolling release */
+    stages: StartRollingReleaseResponseRollingReleaseStagesList;
+    /** The currently active stage, null if the rollout is aborted */
+    activeStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** The next stage to be activated, null if not in ACTIVE state */
+    nextStage: ApproveRollingReleaseStageResponseRollingReleaseStagesItem | null;
+    /** Unix timestamp in milliseconds when the rolling release started */
+    startedAt: number;
+    /** Unix timestamp in milliseconds when the rolling release was last updated */
+    updatedAt: number;
+    /** When set (for example while {@link substate} is `PAUSED`), the canary traffic percentage persisted on the rollout document — use for dashboard display when linear shift is active. */
+    currentCanaryPercentage?: number;
+}
+export declare const StartRollingReleaseResponseRollingRelease: S.Schema<StartRollingReleaseResponseRollingRelease>;
+export interface StartRollingReleaseResponse {
+    /** Rolling release information including configuration and document details, or null if no rolling release exists */
+    rollingRelease: StartRollingReleaseResponseRollingRelease | null;
+}
+export declare const StartRollingReleaseResponse: S.Schema<StartRollingReleaseResponse>;
+export interface UpdateRollingReleaseConfigRequest {
+    /** Project ID or project name (URL-encoded) */
+    idOrName: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const UpdateRollingReleaseConfigRequest: S.Schema<UpdateRollingReleaseConfigRequest>;
+export interface UpdateRollingReleaseConfigResponseBodyCase0 {
+    rollingRelease: unknown | null;
+}
+export declare const UpdateRollingReleaseConfigResponseBodyCase0: S.Schema<UpdateRollingReleaseConfigResponseBodyCase0>;
+/** A stage object configured for a rolling release once a new deployment is triggered the first stage will be read in the proxy for first time visitors, and if a RNG < targetPercentage then it will serve the new deployment. Upon approval the next stage will be read, etc. */
+export type UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesItem = GetRollingReleaseConfigResponseRollingReleaseStagesItem;
+export declare const UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesItem: S.Schema<GetRollingReleaseConfigResponseRollingReleaseStagesItem>;
+export type UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesList = Array<GetRollingReleaseConfigResponseRollingReleaseStagesItem>;
+export declare const UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesList: S.Schema<UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesList>;
+export interface UpdateRollingReleaseConfigResponseBodyCase1RollingRelease {
+    stages?: UpdateRollingReleaseConfigResponseBodyCase1RollingReleaseStagesList | null;
+}
+export declare const UpdateRollingReleaseConfigResponseBodyCase1RollingRelease: S.Schema<UpdateRollingReleaseConfigResponseBodyCase1RollingRelease>;
+export interface UpdateRollingReleaseConfigResponseBodyCase1 {
+    rollingRelease: UpdateRollingReleaseConfigResponseBodyCase1RollingRelease | null;
+}
+export declare const UpdateRollingReleaseConfigResponseBodyCase1: S.Schema<UpdateRollingReleaseConfigResponseBodyCase1>;
+export type UpdateRollingReleaseConfigResponseBody = UpdateRollingReleaseConfigResponseBodyCase0 | UpdateRollingReleaseConfigResponseBodyCase1;
+export declare const UpdateRollingReleaseConfigResponseBody: S.Schema<UpdateRollingReleaseConfigResponseBody>;
+export type UpdateRollingReleaseConfigResponse = UpdateRollingReleaseConfigResponseBody;
+export declare const UpdateRollingReleaseConfigResponse: S.Schema<UpdateRollingReleaseConfigResponse>;
+export type ApproveRollingReleaseStageError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Update the active rolling release to the next stage for a project Advance a rollout to the next stage. This is only needed when rolling releases is configured to require manual approval. */
+export declare const approveRollingReleaseStage: API.OperationMethod<ApproveRollingReleaseStageRequest, ApproveRollingReleaseStageResponse, ApproveRollingReleaseStageError, VercelOpContext>;
+export type CompleteRollingReleaseError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Complete the rolling release for the project Force-complete a Rolling Release. The canary deployment will begin serving 100% of the traffic. */
+export declare const completeRollingRelease: API.OperationMethod<CompleteRollingReleaseRequest, CompleteRollingReleaseResponse, CompleteRollingReleaseError, VercelOpContext>;
+export type DeleteRollingReleaseConfigError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Delete rolling release configuration Disable Rolling Releases for a project means that future deployments will not undergo a rolling release. Changing the config never alters a rollout that's already in-flight—it only affects the next production deployment. If you want to also stop the current rollout, call this endpoint to disable the feature, and then call either the /complete or /abort endpoint. */
+export declare const deleteRollingReleaseConfig: API.OperationMethod<DeleteRollingReleaseConfigRequest, DeleteRollingReleaseConfigResponse, DeleteRollingReleaseConfigError, VercelOpContext>;
+export type GetRollingReleaseError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get the active rolling release information for a project Return the Rolling Release for a project, regardless of whether the rollout is active, aborted, or completed. If the feature is enabled but no deployment has occurred yet, null will be returned. */
+export declare const getRollingRelease: API.OperationMethod<GetRollingReleaseRequest, GetRollingReleaseResponse, GetRollingReleaseError, VercelOpContext>;
+export type GetRollingReleaseBillingStatusError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get rolling release billing status Get the Rolling Releases billing status for a project. The team level billing status is used to determine if the project can be configured for rolling releases. */
+export declare const getRollingReleaseBillingStatus: API.OperationMethod<GetRollingReleaseBillingStatusRequest, GetRollingReleaseBillingStatusResponse, GetRollingReleaseBillingStatusError, VercelOpContext>;
+export type GetRollingReleaseConfigError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get rolling release configuration Get the Rolling Releases configuration for a project. The project-level config is simply a template that will be used for any future rolling release, and not the configuration for any active rolling release. */
+export declare const getRollingReleaseConfig: API.OperationMethod<GetRollingReleaseConfigRequest, GetRollingReleaseConfigResponse, GetRollingReleaseConfigError, VercelOpContext>;
+export type StartRollingReleaseError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Start a rolling release for the project Start a rolling release for a deployment. If a rolling release is already active for the same canary deployment, returns the current state without side effects. */
+export declare const startRollingRelease: API.OperationMethod<StartRollingReleaseRequest, StartRollingReleaseResponse, StartRollingReleaseError, VercelOpContext>;
+export type UpdateRollingReleaseConfigError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Update the rolling release settings for the project Update (or disable) Rolling Releases for a project. When disabling with the resolve-on-disable feature flag enabled, any active rolling release document is resolved using the disableRolloutAction parameter: "abort" to roll back (default), or "complete" to promote the canary to production. When enabling or updating config, changes only affect the next production deployment and do not alter a rollout that's already in-flight. Note: Enabling Rolling Releases automatically enables skew protection on the project with the default value if it wasn't configured already. */
+export declare const updateRollingReleaseConfig: API.OperationMethod<UpdateRollingReleaseConfigRequest, UpdateRollingReleaseConfigResponse, UpdateRollingReleaseConfigError, VercelOpContext>;
+//# sourceMappingURL=rolling_release.d.ts.map