@rebasepro/cli 0.25.1 → 0.26.0

package/dist/commands/cloud/deploy.d.ts

@@ -10,9 +10,50 @@
  * this directory as a build context, and the bare form uploads nothing and asks
  * the control plane to rebuild what it already holds. That last one is the
  * dangerous one — see `planBareDeploy`.
+ *
+ * `--preview` is the bundle deploy aimed somewhere else: the same build and
+ * upload, triggered through the `previews` function so it is served on an
+ * address of its own and production is never touched. See `previews.ts`.
  */
 import arg from "arg";
 import { type CloudClient } from "./context.js";
+/** Printed under a successful deploy: the way back, where it is needed. */
+export declare const ROLLBACK_HINT = "Something wrong? `rebase cloud rollback` puts the previous deployment back.";
+/**
+ * The same line for a static app deployed on its own. Its deployment records
+ * no bundle, so the control plane has nothing to roll back to (see the
+ * "Roll back" section of the cloud deployment docs). Pointing at
+ * `rollback` here would restore the backend instead, or refuse.
+ */
+export declare const STATIC_UNDO_HINT = "Something wrong? A static app deployed on its own cannot be rolled back yet: deploy its last good version again.";
+/**
+ * Stop the deploy on a syntax error in a static app's output, before anything
+ * is uploaded. See `checkStaticSyntax`.
+ *
+ * A static app's files are served as they are, so a broken script that no
+ * bundler ever parsed went live and took the page down with it. Nothing on the
+ * way said so: the build "succeeded" by copying it, and the deploy succeeded
+ * by uploading it. `--no-verify` is the way past for a file the check gets
+ * wrong.
+ */
+export declare function verifyStaticOutput(projectRoot: string, apps: {
+    name: string;
+    output?: string;
+}[]): void;
+/** What `--preview` and `--preview-name` asked for. */
+export interface PreviewRequest {
+    /** A stable name, so later deploys update the same address; absent, the control plane picks one. */
+    name?: string;
+}
+/**
+ * `--preview` / `--preview-name <name>` off the parsed flags, or undefined for
+ * a production deploy. A name alone is a preview: nobody names a production
+ * deploy's address.
+ */
+export declare function resolvePreviewRequest(flags: {
+    "--preview"?: boolean;
+    "--preview-name"?: string;
+}): PreviewRequest | undefined;
 /** A project row, reduced to what says how it deploys (camel or snake columns). */
 export interface DeployProjectRow {
     runtimeMode?: string;
@@ -195,6 +236,7 @@ export declare const DEPLOY_FLAGS: {
     readonly "--no-follow": BooleanConstructor;
     readonly "--wait": BooleanConstructor;
     readonly "--timeout": StringConstructor;
+    readonly "--live-timeout": StringConstructor;
     readonly "--source": StringConstructor;
     readonly "--message": StringConstructor;
     readonly "--bundle": BooleanConstructor;
@@ -202,9 +244,12 @@ export declare const DEPLOY_FLAGS: {
     readonly "--skip-type-check": BooleanConstructor;
     readonly "--no-static": BooleanConstructor;
     readonly "--skip-schema": BooleanConstructor;
+    readonly "--no-verify": BooleanConstructor;
     readonly "--eject": BooleanConstructor;
     readonly "--no-source": BooleanConstructor;
     readonly "--allow-downgrade": BooleanConstructor;
+    readonly "--preview": BooleanConstructor;
+    readonly "--preview-name": StringConstructor;
     readonly "-m": "--message";
 };
 /**
@@ -234,6 +279,7 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
         readonly "--no-follow": BooleanConstructor;
         readonly "--wait": BooleanConstructor;
         readonly "--timeout": StringConstructor;
+        readonly "--live-timeout": StringConstructor;
         readonly "--source": StringConstructor;
         readonly "--message": StringConstructor;
         readonly "--bundle": BooleanConstructor;
@@ -241,9 +287,12 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
         readonly "--skip-type-check": BooleanConstructor;
         readonly "--no-static": BooleanConstructor;
         readonly "--skip-schema": BooleanConstructor;
+        readonly "--no-verify": BooleanConstructor;
         readonly "--eject": BooleanConstructor;
         readonly "--no-source": BooleanConstructor;
         readonly "--allow-downgrade": BooleanConstructor;
+        readonly "--preview": BooleanConstructor;
+        readonly "--preview-name": StringConstructor;
         readonly "-m": "--message";
     } & {
         readonly "--json": BooleanConstructor;
@@ -258,6 +307,15 @@ export declare function resolveDeployArgs(rawArgs: string[]): {
     appName: string | undefined;
 };
 export declare function deployCommand(rawArgs: string[], projectRef: string): Promise<void>;
+/**
+ * `--live-timeout <seconds>`: how long a deploy waits for the new version to
+ * answer before saying it could not confirm it. `0` skips the check. Default 60.
+ *
+ * Its own reader rather than `resolveTimeoutMs`, which refuses 0 — right for a
+ * follow, where 0 would mean "give up at once", and wrong here, where it is the
+ * documented way to say "do not check".
+ */
+export declare function resolveLiveTimeout(value: string | undefined): number;
 /** `--timeout <seconds>` for a deploy, or the 15-minute default. */
 export declare function resolveDeployTimeout(value: string | undefined): number;
 /**
@@ -348,5 +406,11 @@ export declare const LOGS_FLAGS: {
     readonly "--runtime": BooleanConstructor;
     readonly "--follow": BooleanConstructor;
     readonly "-f": "--follow";
+    readonly "--since": StringConstructor;
+    readonly "--tail": NumberConstructor;
+    readonly "--previous": BooleanConstructor;
+    readonly "--grep": StringConstructor;
+    readonly "--level": StringConstructor;
+    readonly "--preview": BooleanConstructor;
 };
 export declare function logsCommand(rawArgs: string[], projectRef: string): Promise<void>;

package/dist/commands/cloud/env.d.ts

@@ -1,3 +1,7 @@
+/** `--preview`: act on what the project's previews run with, not production. */
+export declare const ENV_PREVIEW_FLAGS: {
+    readonly "--preview": BooleanConstructor;
+};
 export declare function envCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
 /** Parse `KEY=VALUE` or `KEY VALUE` from the positional operands. */
 export declare function parseEnvAssignment(operands: string[]): {
@@ -8,8 +12,20 @@ export declare function parseEnvAssignment(operands: string[]): {
 export declare function buildTimeEnvPrefix(key: string): string | undefined;
 /** The flags `rebase cloud env set` takes, on top of the global cloud ones. */
 export declare const ENV_SET_FLAGS: {
+    readonly "--preview": BooleanConstructor;
     readonly "--secret": BooleanConstructor;
     readonly "--force": BooleanConstructor;
+    readonly "--stdin": BooleanConstructor;
+};
+/**
+ * The value `env set KEY --stdin` was piped: everything on standard input,
+ * less the one line ending `echo` and a here-string add. Refuses a terminal
+ * (it would wait for a value nobody knows to type) and a line that also gives
+ * the value, which would leave two candidates.
+ */
+export declare function envValueFromStdin(operands: string[], read?: () => string, isTTY?: boolean): {
+    key: string;
+    value: string;
 };
 /**
  * What `env set` was asked to store.
@@ -27,8 +43,10 @@ export declare const ENV_SET_FLAGS: {
  */
 export declare function resolveEnvSetArgs(rawArgs: string[]): {
     flags: import("arg").Result<{
+        readonly "--preview": BooleanConstructor;
         readonly "--secret": BooleanConstructor;
         readonly "--force": BooleanConstructor;
+        readonly "--stdin": BooleanConstructor;
     } & {
         readonly "--json": BooleanConstructor;
         readonly "--yes": BooleanConstructor;
@@ -39,6 +57,7 @@ export declare function resolveEnvSetArgs(rawArgs: string[]): {
         readonly "-y": "--yes";
         readonly "-h": "--help";
     }>;
+    positionals: string[];
     assignment: {
         key: string;
         value: string;
@@ -57,6 +76,11 @@ export declare function resolveEnvSetArgs(rawArgs: string[]): {
  * count of command words is the same for all of them.
  */
 export declare function resolveEnvKeyArg(rawArgs: string[], action: string): string | undefined;
+/** {@link resolveEnvKeyArg}, and whether `--preview` was given (`unset` and `reset` take it). */
+export declare function resolveEnvKeyArgs(rawArgs: string[], action: string): {
+    key: string | undefined;
+    preview: boolean;
+};
 /**
  * One `KEY=value` line that dotenv reads back as exactly `value`, or null when
  * no quoting can carry it.

package/dist/commands/cloud/index.d.ts

@@ -20,6 +20,8 @@ import { type HelpAction } from "./context.js";
  */
 export declare const CLOUD_VALUE_FLAGS: {
     readonly "--access-key-id": StringConstructor;
+    readonly "--action": StringConstructor;
+    readonly "--actor": StringConstructor;
     readonly "--autoscale-cpu-target": StringConstructor;
     readonly "--autoscale-max": StringConstructor;
     readonly "--backup-access-key-id": StringConstructor;
@@ -27,6 +29,7 @@ export declare const CLOUD_VALUE_FLAGS: {
     readonly "--backup-endpoint": StringConstructor;
     readonly "--backup-secret-access-key": StringConstructor;
     readonly "--base-domain": StringConstructor;
+    readonly "--before": StringConstructor;
     readonly "--branch": StringConstructor;
     readonly "--bucket": StringConstructor;
     readonly "--bundle-dir": StringConstructor;
@@ -42,23 +45,33 @@ export declare const CLOUD_VALUE_FLAGS: {
     readonly "--endpoint": StringConstructor;
     readonly "--events": StringConstructor;
     readonly "--expires-in": StringConstructor;
+    readonly "--format": StringConstructor;
     readonly "--function": StringConstructor;
+    readonly "--grep": StringConstructor;
     readonly "--host": StringConstructor;
     readonly "--ingress-address": StringConstructor;
     readonly "--kubeconfig": StringConstructor;
+    readonly "--level": StringConstructor;
     readonly "--limit": StringConstructor;
+    readonly "--live-timeout": StringConstructor;
     readonly "--memory": StringConstructor;
     readonly "--message": StringConstructor;
+    readonly "--month": StringConstructor;
     readonly "--name": StringConstructor;
     readonly "--org": StringConstructor;
     readonly "--output": StringConstructor;
     readonly "--password": StringConstructor;
     readonly "--platform-rebuilds": StringConstructor;
     readonly "--port": StringConstructor;
+    readonly "--preview-name": StringConstructor;
     readonly "--provider": StringConstructor;
+    readonly "--pull-key-file": StringConstructor;
+    readonly "--push-service-account": StringConstructor;
     readonly "--region": StringConstructor;
     readonly "--replicas": StringConstructor;
     readonly "--repo": StringConstructor;
+    readonly "--repository": StringConstructor;
+    readonly "--role": StringConstructor;
     readonly "--scale-to-zero": StringConstructor;
     readonly "--secret-access-key": StringConstructor;
     readonly "--since": StringConstructor;
@@ -67,7 +80,6 @@ export declare const CLOUD_VALUE_FLAGS: {
     readonly "--spot": StringConstructor;
     readonly "--storage": StringConstructor;
     readonly "--subdomain": StringConstructor;
-    readonly "--table": StringConstructor;
     readonly "--tail": StringConstructor;
     readonly "--target": StringConstructor;
     readonly "--timeout": StringConstructor;

package/dist/commands/cloud/init.d.ts

@@ -0,0 +1,143 @@
+import { dotenvSets } from "./context.js";
+/** What `rebase cloud init` parses, beside the global flags. Exported so its help page cannot drift. */
+export declare const INIT_FLAGS: {
+    readonly "--claim": BooleanConstructor;
+    readonly "--name": StringConstructor;
+    readonly "-n": "--name";
+    readonly "--no-deploy": BooleanConstructor;
+};
+/** The variable the app, the SDK and the MCP server read the backend's address from. */
+export declare const BASE_URL_ENV = "REBASE_BASE_URL";
+/** The variable the MCP server and the SDK read the app's key from. */
+export declare const API_TOKEN_ENV = "REBASE_API_TOKEN";
+/** What `POST /api/functions/ephemeral/provision` answers. */
+export interface ProvisionedProject {
+    projectId: string;
+    slug: string;
+    name: string;
+    projectUrl: string;
+    apiKey: string;
+    claimUrl: string;
+    expiresAt: string;
+}
+/**
+ * Ask the control plane for a project. No credential: this is the one call in
+ * the family that is made by nobody.
+ */
+export declare function requestEphemeralProject(url: string, name: string | undefined): Promise<ProvisionedProject>;
+/** What `POST /api/functions/ephemeral/app-key` answers: a key minted on the app itself. */
+export interface AppKey {
+    apiKey: string;
+    keyId: string;
+    scopes: string[];
+    expiresAt: string;
+}
+export type AppKeyOutcome = {
+    ok: true;
+    key: AppKey;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+export interface AppKeyRetry {
+    /** How many times to ask while the app is still coming up. */
+    attempts: number;
+    sleep: (ms: number) => Promise<void>;
+}
+/**
+ * Ask the control plane for a key the deployed app accepts, with the project's
+ * own token.
+ *
+ * The control plane mints it on the app through the app's admin key route: a
+ * service key holding `data:read` and `data:write` and nothing else, running
+ * through the app's row-level security as a caller who is neither a person nor
+ * an admin, expiring with the claim window. Never fatal: the project and its
+ * claim link stand without it, so a refusal comes back as an outcome to report.
+ *
+ * Asks again only while the app is not answering yet, the state a rollout
+ * that has just finished can still be in: a 503 from the control plane (the
+ * app did not answer), or a 502/504 (the app's gateway answered for it — the
+ * control plane passes any non-2xx from the app on as 502).
+ */
+export declare function requestAppKey(url: string, token: string, projectId: string, retry?: AppKeyRetry): Promise<AppKeyOutcome>;
+/**
+ * Set one variable in a `.env`, keeping every other line as it was: replaced
+ * where it is already set, appended where it is not.
+ */
+export declare function upsertDotenv(file: string, key: string, value: string): void;
+export { dotenvSets };
+/**
+ * Set on the deploy `init` runs as a child. `init` asks for the app's key
+ * itself once that deploy is done, and reports it in its own result, so the
+ * child leaves it alone: asked twice, the second key revokes the first.
+ */
+export declare const INIT_CHILD_DEPLOY_ENV = "REBASE_CLOUD_INIT_DEPLOY";
+/** The key's outcome as a result reports it. Never the key: this output reaches an agent's transcript. */
+export declare function appKeyPayload(outcome: AppKeyOutcome): Record<string, unknown>;
+/**
+ * After `rebase cloud deploy` succeeded: the app's key, when this directory is
+ * linked to an unclaimed project and its `.env` has none yet.
+ *
+ * `init` asks for the key right after its own deploy, so a project provisioned
+ * with `--no-deploy`, or whose first deploy failed, had no way to get one, and
+ * `init` does not run again in a linked directory. The next deploy that builds
+ * the app is that way.
+ *
+ * Asks nothing when the project is claimed or its grant has expired (there is
+ * no grant then), when the deploy was for a project other than the linked one,
+ * or when `.env` already sets `REBASE_API_TOKEN`: that may be a key someone
+ * made by hand, and a new one revokes the last one minted. Never throws, since
+ * the deploy succeeded either way, and answers `undefined` when it asked nothing.
+ */
+export declare function mintMissingAppKey(opts: {
+    url: string;
+    projectId: string;
+    /** The directory holding the link and `.env`: the project root, or the working directory. */
+    root?: string;
+    appKey?: InitDeps["appKey"];
+}): Promise<AppKeyOutcome | undefined>;
+/**
+ * Say how {@link mintMissingAppKey} went, under a deploy's verdict and before
+ * its result. A refusal is a warning, in every output mode: the deploy
+ * succeeded regardless. JSON carries the same through {@link appKeyPayload}.
+ */
+export declare function reportMintedAppKey(outcome: AppKeyOutcome | undefined): void;
+/**
+ * Where the project's CMS is served once deployed: the mount `rebase.json`
+ * declares, on the project's own host unless that app names its own.
+ */
+export declare function adminPanelUrl(projectRoot: string | null, projectUrl: string): string | undefined;
+/** How a deploy went, as `rebase cloud deploy --json` reported it. */
+export interface DeployOutcome {
+    ok: boolean;
+    /** The deploy's own JSON result or error, when it printed one. */
+    result?: unknown;
+}
+/**
+ * The environment of {@link runBundleDeploy}'s child: this one, marked as
+ * init's own deploy, and without `REBASE_TOKEN`.
+ *
+ * `REBASE_TOKEN` outranks the stored grant (see `requireClient`), and a shell
+ * or an MCP server that has one holds it for the person's other projects — it
+ * has no scope on the project just provisioned, so the deploy was refused and
+ * the project never got its collections. The project is deployed with its own
+ * token.
+ */
+export declare function bundleDeployEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * Push the local collections: `rebase cloud deploy --bundle`, as a child.
+ *
+ * A child rather than a call, so this command still prints exactly one
+ * result — a JSON caller gets the deploy's outcome folded into it — and still
+ * prints the claim link when the deploy fails. The child finds the project
+ * through the link just written, and its token through the credentials file.
+ * It asks for no app key: this command does, after it (see {@link INIT_CHILD_DEPLOY_ENV}).
+ */
+export declare function runBundleDeploy(cwd: string, json: boolean): Promise<DeployOutcome>;
+export interface InitDeps {
+    provision: typeof requestEphemeralProject;
+    deploy: typeof runBundleDeploy;
+    appKey: (url: string, token: string, projectId: string) => Promise<AppKeyOutcome>;
+}
+export declare function cloudInitCommand(rawArgs: string[], deps?: InitDeps): Promise<void>;

package/dist/commands/cloud/login-flow.d.ts

@@ -0,0 +1,51 @@
+import { type CloudClient } from "./context.js";
+type CloudAuth = CloudClient["auth"];
+type SignedIn = Awaited<ReturnType<CloudAuth["signInWithEmail"]>>;
+/** How many codes one login takes before it gives up. The server limits verification per address too. */
+export declare const CODE_ATTEMPTS = 3;
+/**
+ * The remedy for a step that needs a terminal when there is none: a token,
+ * which needs neither a password nor a code. Minted in the console because a
+ * person who cannot log in to the CLI cannot run `rebase cloud tokens create`.
+ */
+export declare const TOKEN_REMEDY = "Create an access token in the console (Settings \u2192 Access tokens) and set REBASE_TOKEN to it.";
+/** What the password refusal adds, for the accounts that never had a password. */
+export declare const NO_PASSWORD_HINT: string;
+/** A sign-in waiting for its second factor. */
+export interface PendingSecondFactor {
+    mfaToken: string;
+    factors: Array<{
+        id: string;
+        factorType: string;
+        friendlyName?: string;
+    }>;
+}
+/**
+ * The pending sign-in an `MFA_REQUIRED` refusal describes, or `null` for any
+ * other error — including one with no token or no factor, which no code step
+ * could finish. The same reading the console's login view makes.
+ */
+export declare function readMfaRequired(error: unknown): PendingSecondFactor | null;
+/**
+ * Whether the control plane mails sign-in codes, as its `/auth/config` says.
+ * `false` when it cannot be asked: an older control plane has no such door,
+ * and offering one that 404s is worse than not offering it.
+ */
+export declare function offersSignInCodes(auth: CloudAuth): Promise<boolean>;
+/** Ask "password or code?" at a terminal. */
+export declare function askSignInMethod(): Promise<"password" | "code">;
+/** Refuse a code step with no terminal to type it at. Never returns when there is none. */
+export declare function requireTerminalForCode(): void;
+/**
+ * Mail a code to `email` and trade what the person types for a session.
+ *
+ * Throws what `verifyEmailOtp` throws for anything but a wrong code —
+ * `MFA_REQUIRED` included, which the caller's {@link withSecondFactor} answers.
+ */
+export declare function signInWithCode(auth: CloudAuth, email: string): Promise<SignedIn>;
+/**
+ * Run a sign-in, and when the account has 2FA on, ask for the second factor
+ * and finish it there.
+ */
+export declare function withSecondFactor(auth: CloudAuth, signIn: () => Promise<SignedIn>): Promise<SignedIn>;
+export {};

package/dist/commands/cloud/notifications.d.ts

@@ -0,0 +1,28 @@
+/** The events the control plane notifies about. */
+export declare const NOTIFICATION_EVENTS: readonly ["deploy.failed", "deploy.succeeded", "deploy.rolled_back", "backup.unhealthy", "billing.payment_failed", "usage.threshold", "preview.paused"];
+export declare const NOTIFICATIONS_ACTIONS: readonly ["list", "add", "test", "remove"];
+export declare const NOTIFICATIONS_ADD_FLAGS: {
+    readonly "--events": StringConstructor;
+    readonly "--format": StringConstructor;
+    readonly "--name": StringConstructor;
+};
+/** A destination, as the control plane lists it. */
+export interface CliNotificationWebhook {
+    id: string;
+    name: string;
+    url: string;
+    events: string[];
+    format: "json" | "slack";
+    enabled: boolean;
+    lastStatus: number | null;
+    lastError: string;
+    lastDeliveredAt: string | null;
+    failureCount: number;
+    createdAt: string | null;
+}
+/**
+ * `--events deploy.failed,backup.unhealthy` as a list, refused when it names an
+ * event that does not exist. Exported so its test drives the real parser.
+ */
+export declare function parseNotificationEvents(raw: string | undefined): string[];
+export declare function notificationsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;

package/dist/commands/cloud/orgs.d.ts

@@ -5,4 +5,17 @@ export declare const CREATE_ORG_FLAGS: {
     readonly "--slug": StringConstructor;
     readonly "-n": "--name";
 };
+/** An open invitation, as the control plane lists it. Never the link. */
+export interface CliInvite {
+    id: string;
+    email: string;
+    role: string;
+    invitedBy: {
+        userId: string | null;
+        email: string | null;
+    };
+    expiresAt: string;
+    expired: boolean;
+    createdAt: string | null;
+}
 export declare function printOrgsHelp(): void;

package/dist/commands/cloud/previews.d.ts

@@ -0,0 +1,123 @@
+import { type CloudClient } from "./context.js";
+/** The control-plane function that creates, lists and deletes previews. */
+export declare const PREVIEWS_FUNCTION = "previews";
+/**
+ * The collection a preview's deployment row lives in.
+ *
+ * Not `deployments`. Every reader of that collection — `cloud status`, `cloud
+ * logs`, rollback, the console's history, and every CLI already installed —
+ * takes its newest row to be what production runs. A preview row there would be
+ * reported as production by all of them, including the versions nobody can
+ * update any more.
+ */
+export declare const PREVIEW_DEPLOYMENTS_COLLECTION = "preview-deployments";
+/** Longest preview name: what leaves the host inside one 63-character DNS label. */
+export declare const MAX_PREVIEW_NAME_LENGTH = 24;
+/**
+ * A preview name as typed, checked and lowercased — or a refusal.
+ *
+ * It becomes part of a hostname, `<project>--<name>`, so it is held to a DNS
+ * label's alphabet. A double hyphen is refused because the host is split on
+ * it: a name holding one could never be told apart from the project's own.
+ */
+export declare function normalizePreviewName(raw: string): string;
+/** Which backend a preview's pages talk to. */
+export type PreviewBackend = "preview" | "production";
+/** A preview as the control plane describes it. */
+export interface Preview {
+    name: string;
+    /** `https://shop--new-quiz.rebase.website`. */
+    url: string;
+    /** The app it serves: a static app's name, or the backend. */
+    app: string | null;
+    /**
+     * `preview` when the preview runs a backend of its own, with its own
+     * database; `production` when it is only files, calling the production API.
+     */
+    backend: PreviewBackend | null;
+    status: string | null;
+    /** Why it is in its status, as the control plane wrote it — set for `paused` (its database outgrew the preview limit). */
+    statusMessage: string | null;
+    /** The deployment that built it, in {@link PREVIEW_DEPLOYMENTS_COLLECTION}. */
+    deploymentId: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** When the control plane deletes it on its own, unless it is deployed again. */
+    expiresAt: string | null;
+}
+/**
+ * One preview out of an answer, read defensively — or null when it names no
+ * address, which is the one field a preview cannot be reported without.
+ */
+export declare function previewFrom(value: unknown): Preview | null;
+/**
+ * Whether a refusal means "this control plane has no previews" — and not, say,
+ * "no such preview".
+ *
+ * A control plane answers a function it does not serve with a 404 coded
+ * `FUNCTION_NOT_FOUND`; one from before that envelope, with a bare `Not Found`
+ * or `No route for …`. Either is a missing route.
+ */
+export declare function isPreviewsUnavailable(e: unknown): boolean;
+/**
+ * The intake code a control plane refuses a static app's own preview with when
+ * nothing on it serves static sites by themselves (no front door). Rebase Cloud
+ * is one, today: every host is served by the project's own pod.
+ */
+export declare const PREVIEW_STATIC_UNSERVED = "PREVIEW_STATIC_UNSERVED";
+/** What the `previews` trigger answers. */
+export interface PreviewTrigger {
+    deploymentId: string;
+    preview: Preview;
+}
+/**
+ * Ask the control plane to build a preview from an uploaded bundle.
+ *
+ * The body is a bundle deploy's, plus `preview`; see `bundleDeployBody`. An
+ * answer without a preview address is refused rather than followed: whatever
+ * it built, this command cannot say where, and "it is somewhere" is not a
+ * result.
+ */
+export declare function triggerPreview(client: CloudClient, projectId: string, body: Record<string, unknown>, refusal: (e: unknown) => void): Promise<PreviewTrigger>;
+/** The lines a finished preview deploy prints under its verdict. */
+export declare function previewLines(preview: Preview): string[];
+/** Where the docs state what a backend preview costs. */
+export declare const PREVIEW_PRICING_DOCS = "https://rebase.pro/docs/deployment/cloud/#preview-a-change";
+/** The billing rule in words: what is printed when the control plane cannot put a number on it. */
+export declare const PREVIEW_PRICING_RULE: string;
+/** What a backend preview costs, as the control plane quotes it. */
+export interface PreviewCost {
+    /** €/month one backend preview adds to the project's quote; null when it could not be priced. */
+    perPreviewMonthlyEur: number | null;
+    /** Backend previews the project runs, this one included; null when unknown. */
+    backendPreviews: number | null;
+    /** €/month all of them add together; null when unknown. */
+    previewsMonthlyEur: number | null;
+    /** The rule the numbers come from, in words. */
+    rule: string;
+    docs: string;
+}
+/**
+ * What a backend preview costs, in the control plane's own numbers.
+ *
+ * No price is written down here: the control plane quotes the project's dials
+ * with and without backend previews (`pricing/quote` with `backendPreviews`,
+ * the call the console's quote makes) and the difference is what they add —
+ * which follows the rate card, the app's region and its capacity class as
+ * they change. One batched call, best-effort: a control plane that does not
+ * price previews (its answer does not echo the count it was sent) or cannot be
+ * asked leaves the numbers null, and the rule and the docs carry the answer.
+ *
+ * The quote is asked with no credential. The route is public — it prices a
+ * hypothetical and reads nobody's data — and an access token would be refused
+ * on it, holding no `functions:invoke:pricing`: no token capability names it,
+ * and none needs to.
+ */
+export declare function previewCost(client: CloudClient, url: string, projectId: string): Promise<PreviewCost>;
+/** The line a preview deploy prints about its cost. */
+export declare function previewCostLines(cost: PreviewCost, previewName: string): string[];
+/** The flags `previews list` parses — the help page lists exactly these. */
+export declare const PREVIEWS_LIST_FLAGS: {};
+/** The flags `previews delete` parses, beyond the global `--yes`. */
+export declare const PREVIEWS_DELETE_FLAGS: {};
+export declare function previewsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;