/**
 * Cleanup fences must be able to represent the exact revision value Rampway
 * persisted for local-copy deployments, including branch labels. Keep the
 * token bounded and safe to pass as one shell-quoted CLI argument.
 *
 * @param {unknown} value
 * @returns {value is string}
 */
export function isSafePersistedRevision(value: unknown): value is string;
/** @typedef {{releaseId: string, runtimeOwnerIdentity: string, runtimeType: string}} RuntimeReleasePin */
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @returns {Promise<void>}
 */
export function ensureBaseDirs(transport: import("#types").Transport, stage: import("#types").StageConfig): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {string} releasePath
 * @returns {Promise<void>}
 */
export function prepareSharedLinks(transport: import("#types").Transport, stage: import("#types").StageConfig, releasePath: string): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {string} releasePath
 * @returns {Promise<void>}
 */
export function publishCurrent(transport: import("#types").Transport, stage: import("#types").StageConfig, releasePath: string): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @returns {Promise<string[]>}
 */
export function listReleases(transport: import("#types").Transport, stage: import("#types").StageConfig): Promise<string[]>;
/**
 * Plans release retention against live state without deleting anything.
 *
 * The plan classifies every retained release: managed releases count toward
 * `keep`; the `current` target, the active release, and every draining release
 * in Rampway runtime state, plus every runtime release pin, are protected with
 * explicit reasons and never removable; and the oldest managed releases beyond
 * the keep window are removable only while unprotected. Retained and remaining
 * reflect the live state, so protected references can raise the retained total
 * above `keep` without the plan promising a fixed count.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {{keep?: number}} [opts]
 * @returns {Promise<import('#types').ReleaseCleanupPlan>}
 */
export function planReleaseCleanup(transport: import("#types").Transport, stage: import("#types").StageConfig, { keep }?: {
    keep?: number;
}): Promise<import("#types").ReleaseCleanupPlan>;
/**
 * Deletes the planned removable releases idempotently.
 *
 * A failed remote deletion is ambiguous: the live release directory is
 * re-read before deciding whether the deletion executed, so neither outcome is
 * assumed from the transport failure alone. A release that is already gone,
 * for example after an earlier ambiguous attempt, is skipped without inflating
 * the removal count. The result is verified by re-planning live state, and the
 * returned removals were present immediately before this execution attempted
 * them and are confirmed absent by readback.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {import('#types').ReleaseCleanupPlan} plan
 * @returns {Promise<{removed: string[], remaining: string[], plan: import('#types').ReleaseCleanupPlan}>}
 */
export function executeReleaseCleanup(transport: import("#types").Transport, stage: import("#types").StageConfig, plan: import("#types").ReleaseCleanupPlan): Promise<{
    removed: string[];
    remaining: string[];
    plan: import("#types").ReleaseCleanupPlan;
}>;
/**
 * Plans and executes release retention cleanup.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {{keep?: number}} [opts]
 * @returns {Promise<string[]>} The releases confirmed removed by readback.
 */
export function cleanupReleases(transport: import("#types").Transport, stage: import("#types").StageConfig, { keep }?: {
    keep?: number;
}): Promise<string[]>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {import('#types').RuntimeSnapshot} runtimeSnapshot
 * @param {string} releaseId
 * @returns {Promise<void>}
 */
export function pinRuntimeReleaseForCleanup(transport: import("#types").Transport, stage: import("#types").StageConfig, runtimeSnapshot: import("#types").RuntimeSnapshot, releaseId: string): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {import('#types').RuntimeSnapshot} runtimeSnapshot
 * @returns {Promise<void>}
 */
export function clearRuntimeReleasePinsForCleanup(transport: import("#types").Transport, stage: import("#types").StageConfig, runtimeSnapshot: import("#types").RuntimeSnapshot): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {import('#types').RuntimeSnapshot} runtimeSnapshot
 * @param {string[]} releaseIds
 * @returns {Promise<void>}
 */
export function reconcileRuntimeReleasePinsForCleanup(transport: import("#types").Transport, stage: import("#types").StageConfig, runtimeSnapshot: import("#types").RuntimeSnapshot, releaseIds: string[]): Promise<void>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {string|null} [currentRelease]
 * @returns {Promise<string|undefined>}
 */
export function previousRelease(transport: import("#types").Transport, stage: import("#types").StageConfig, currentRelease?: string | null): Promise<string | undefined>;
/**
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @returns {Promise<string|null>}
 */
export function currentReleaseId(transport: import("#types").Transport, stage: import("#types").StageConfig): Promise<string | null>;
/**
 * Strictly resolves the active release for an executable operation.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @returns {Promise<{releaseId: string, releasePath: string}>}
 */
export function requireCurrentRelease(transport: import("#types").Transport, stage: import("#types").StageConfig): Promise<{
    releaseId: string;
    releasePath: string;
}>;
/**
 * @param {unknown} releaseId
 * @returns {releaseId is string}
 */
export function isSafeRetainedReleaseId(releaseId: unknown): releaseId is string;
/**
 * Resolves one retained directory without trusting lexical containment alone.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {string} releaseId
 * @returns {Promise<{releaseId: string, releasePath: string}>}
 */
export function resolveRetainedRelease(transport: import("#types").Transport, stage: import("#types").StageConfig, releaseId: string): Promise<{
    releaseId: string;
    releasePath: string;
}>;
/**
 * @param {import('#types').Transport} transport
 * @param {string} releasePath
 * @returns {Promise<string>}
 */
export function readReleaseRevision(transport: import("#types").Transport, releasePath: string): Promise<string>;
/**
 * Verifies that one retained release belongs to this Rampway application,
 * stage, release ID, and revision.
 *
 * @param {import('#types').Transport} transport
 * @param {import('#types').StageConfig} stage
 * @param {{releaseId: string, releasePath: string}} release
 * @param {string} revision
 * @returns {Promise<Record<string, unknown>>}
 */
export function requireReleaseMetadata(transport: import("#types").Transport, stage: import("#types").StageConfig, release: {
    releaseId: string;
    releasePath: string;
}, revision: string): Promise<Record<string, unknown>>;
export const RETENTION_CLEANUP_SCAN_CONCURRENCY: 4;
export type RuntimeReleasePin = {
    releaseId: string;
    runtimeOwnerIdentity: string;
    runtimeType: string;
};
//# sourceMappingURL=release-manager.d.ts.map