/** The control plane's verdict on what a tenant's uploads actually do. */
interface StorageState {
    effective?: {
        kind?: string;
        summary?: string;
        storageType?: string;
        missing?: string[];
    };
    source?: string;
    configured?: string;
    overridden?: boolean;
}
/**
 * One line describing this project's storage — or `undefined` when the control
 * plane could not be asked, which prints as a blank rather than a guess.
 *
 * `status` used to render the `storages` row and nothing else, so a project
 * whose bucket is configured through its own `STORAGE_TYPE`/`S3_*` variables —
 * the supported path, and the one `mergeStorageEnv` deliberately lets WIN over
 * the row — was reported as `Storage: none` while its pod logged `Initialized
 * storage backends count: 1` against a live bucket. Storage is the thing an app
 * refuses to boot without, so that false negative sends someone off to
 * provision a bucket they already have. The row is not the answer; the tenant's
 * resolved environment is, and the control plane computes it with the same two
 * functions the build log uses.
 */
export declare function describeStorageState(state: StorageState | undefined): string | undefined;
/**
 * One line describing the database.
 *
 * `connectionStatus` is written `"untested"` at creation and only ever changed
 * by `rebase cloud db test`, so `managed (untested)` was reporting the absence
 * of a manual test as though it were the database's condition — on a project
 * that had just deployed against it. A never-tested database says only its
 * type; the verdict appears once there is one.
 */
export declare function describeDatabaseState(db: Record<string, unknown> | undefined): string | undefined;
/**
 * One line describing what engine is serving this project.
 *
 * Three numbers are in play and they are easy to conflate — I have watched it
 * happen. The **runtime version** (`1.2.0`) is the contract line a bundle's
 * range resolves against; its major IS the contract major. The **framework
 * version** (`0.11.0`) is the `@rebasepro` release the runtime image ships. They
 * move independently on purpose: tying the contract line to the framework would
 * make `^1` become `^0.11`, and pre-1.0 caret is restrictive, so every framework
 * minor would fall outside every project's range and force a rebuild to receive
 * an engine upgrade — the opposite of what the bundle/runtime split is for.
 *
 * So both are printed, rather than leaving anyone to infer one from a Docker tag.
 */
export declare function describeRuntime(project: {
    runtimeMode?: string | null;
    runtimeVersion?: string | null;
    runtimeFrameworkVersion?: string | null;
    runtimeVersionPin?: string | null;
}): string;
export declare function statusCommand(rawArgs: string[]): Promise<void>;
export declare function metricsCommand(rawArgs: string[]): Promise<void>;
/**
 * The webhook `webhooks delete` names.
 *
 * The worst instance of the operand-filter bug in this family, because the
 * argument is consumed by a DELETE and the wrong value looks entirely
 * plausible: `rebase cloud webhooks delete --project acme 42` filtered out
 * `--project` and kept "acme", so the id it deleted was the project slug rather
 * than the 42 the caller wrote. Strict parsing consumes the flag with its
 * value, leaving `["42"]`.
 *
 * Exported so its tests drive the real parser.
 */
export declare function resolveWebhookIdArg(rawArgs: string[]): string | undefined;
export declare function webhooksCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
export declare function storageCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
export declare function printStorageHelp(): void;
/**
 * `rebase cloud clusters` — list, register and verify the clusters tenants run on.
 *
 * Registration is deliberately an operator action: the `clusters` collection is
 * admin-only, and a cluster record carries a credential with enough power to
 * create namespaces and read every secret in them. A self-serve "bring your own
 * cluster" flow is a different feature with a different threat model.
 */
export declare function clustersCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
export declare function billingCommand(rawArgs: string[]): Promise<void>;
/**
 * `rebase cloud resources` — show what a project is given, and change it.
 *
 * ## Why nothing is validated here
 *
 * The rules are the *target cluster's*, not the CLI's: GKE Autopilot bills a
 * 250m/512Mi floor and rewrites anything outside a 1:1–6.5:1 memory:CPU band,
 * while a Hetzner or EKS node has neither constraint. A CLI that carried those
 * numbers would be wrong for two of the three providers the moment it shipped,
 * and would drift from the control plane the first time either changed.
 *
 * So the control plane validates and this reports what it said. The same
 * boundary refuses a raw PATCH and a console save, which is the property worth
 * having — a check in a client only covers the clients that run it.
 */
export declare function resourcesCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
/**
 * Turn `--cpu 500m --db-instances 2` into the patch to send.
 *
 * Pure, and exported, so the flag handling is testable without a control plane —
 * the same shape `buildSettingsPatch` uses. Returns an error string rather than
 * throwing, because the caller owns how a refusal is printed in JSON mode.
 */
export declare function buildDialPatch(rawArgs: string[]): {
    patch: Record<string, unknown>;
    error?: string;
};
export {};