import { type IControllerRuntimeId, type IControllerUpgradeStatus } from '../dist_ts_interfaces/index.js';
export declare const upgradeCoordinationVersion: 2;
declare const coordinationVersion: 2;
export declare const upgradePackageTransitionTransactionVersion: 3;
export declare const upgradePackageTransitionSource: {
    readonly packageName: "@modelprofile.com/harness-controller";
    readonly version: "20.0.3";
    readonly managementVersion: 1;
    readonly cliName: "hcon";
    readonly cliRelativePath: "./cli.js";
};
export declare const upgradePackageTransitionTarget: {
    readonly packageName: "agl";
    readonly version: "21.0.0";
    readonly managementVersion: 2;
    readonly cliName: "agl";
    readonly cliRelativePath: "./cli.js";
};
type TUpgradeOwnerKind = 'upgrade' | 'start';
interface IUpgradeProcessOwner {
    version: typeof coordinationVersion;
    kind: TUpgradeOwnerKind;
    uid: number;
    tokenHash: string;
    pid: number;
    processGroupId: number;
    fingerprint: string;
    cliPath: string;
    command: '__serve' | '__upgrade-worker' | 'upgrade' | 'start' | 'foreground' | 'temp-password';
    createdAt: number;
}
export interface IUpgradeExpectedController {
    pid: number;
    processGroupId: number;
    processFingerprint: string;
}
export interface IUpgradeWorkerPayload {
    version: typeof coordinationVersion;
    token: string;
    port: number;
    gracePeriodMs: number;
    continueSessions: boolean;
    expectedController?: IUpgradeExpectedController;
}
export type TUpgradeSessionTransitionState = 'pending' | 'submitting' | 'accepted' | 'paused' | 'outcomeUnknown' | 'failed';
export interface IUpgradeSessionState {
    projectId: string;
    sessionId: IControllerRuntimeId;
    pauseState: TUpgradeSessionTransitionState;
    pauseQueueId?: string;
    cleanupState?: TUpgradeSessionTransitionState;
    continueState?: TUpgradeSessionTransitionState;
    error?: string;
}
interface IUpgradeTransactionBase {
    tokenHash: string;
    revision: number;
    port: number;
    controllerWasRunning: boolean;
    continueSessions: boolean;
    gracePeriodMs: number;
    preparationAcceptedAt?: number;
    preparationDeadlineAt?: number;
    preparationCompletedAt?: number;
    phase: IControllerUpgradeStatus['phase'] | 'starting' | 'checking' | 'stopping';
    message: string;
    createdAt: number;
    phaseStartedAt: number;
    updatedAt: number;
    retainedUntil?: number;
    worker?: {
        pid: number;
        processGroupId: number;
        fingerprint: string;
        cliPath: string;
        logFilePath?: string;
    };
    controller?: {
        pid: number;
        processGroupId: number;
        fingerprint: string;
        cliPath: string;
        command: '__serve' | 'foreground';
    };
    sessions: IUpgradeSessionState[];
    terminal?: {
        success: boolean;
        error?: string;
    };
}
export interface IUpgradeTransactionV2 extends IUpgradeTransactionBase {
    version: typeof coordinationVersion;
    sourceVersion: string;
    targetVersion?: string;
    registryUrl?: string;
    targetStartupInvoked?: true;
}
export interface IUpgradeTransactionV3 extends IUpgradeTransactionBase {
    version: typeof upgradePackageTransitionTransactionVersion;
    sourcePackageName: typeof upgradePackageTransitionSource.packageName;
    sourceVersion: typeof upgradePackageTransitionSource.version;
    sourceManagementVersion: typeof upgradePackageTransitionSource.managementVersion;
    sourceCliName: typeof upgradePackageTransitionSource.cliName;
    sourceCliRelativePath: typeof upgradePackageTransitionSource.cliRelativePath;
    targetPackageName: typeof upgradePackageTransitionTarget.packageName;
    targetVersion: typeof upgradePackageTransitionTarget.version;
    targetManagementVersion: typeof upgradePackageTransitionTarget.managementVersion;
    targetCliName: typeof upgradePackageTransitionTarget.cliName;
    targetCliRelativePath: typeof upgradePackageTransitionTarget.cliRelativePath;
    recoveryTargetVersion?: string;
    packageTransitionStarted?: true;
    groupedTargetVerified?: true;
    targetPackageCommitStarted?: true;
    targetPackageCommitted?: true;
    targetStartupInvoked?: true;
}
export type TUpgradeTransaction = IUpgradeTransactionV2 | IUpgradeTransactionV3;
export interface IUpgradeTransactionInventoryEntry {
    fileName: string;
    state: 'active' | 'adopting';
    transaction: TUpgradeTransaction;
}
export interface IUpgradeTransactionInventory {
    transactions: IUpgradeTransactionInventoryEntry[];
    tokenMetadataFileNames: string[];
    mutationDirectoryNames: string[];
}
export interface IAdoptOrphanedUpgradeTransactionOptions {
    lock: UpgradeInstallationLock;
    token: string;
    expectedTokenHash: string;
    expectedRevision: number;
    port: number;
    installedVersion: string;
    registryUrl?: string;
}
export type TUpgradeControllerAction = 'prepare' | 'finalize';
export declare const compareUpgradeSemver: (leftArg: string, rightArg: string) => number;
export declare const normalizeUpgradeRegistryUrl: (valueArg: unknown) => string;
export declare const upgradeTransactionIsStalled: (transactionArg: TUpgradeTransaction, nowArg?: number) => boolean;
export declare const upgradeTransactionRequiresForwardRecovery: (transactionArg: TUpgradeTransaction) => boolean;
export declare const upgradeTransactionTargetVersion: (transactionArg: TUpgradeTransaction) => string | undefined;
declare class UpgradeOwnedDirectory {
    readonly directory: string;
    readonly owner: IUpgradeProcessOwner;
    private readonly releaseOwned;
    private released;
    private releaseTask?;
    constructor(directory: string, owner: IUpgradeProcessOwner, releaseOwned: (directoryArg: string, ownerArg: IUpgradeProcessOwner, shouldReleaseArg?: () => boolean) => Promise<void>);
    assertOwned(): Promise<void>;
    release(shouldReleaseArg?: () => boolean): Promise<void>;
    relinquishAfterTransfer(): void;
}
export declare class UpgradeInstallationLock extends UpgradeOwnedDirectory {
}
export declare class UpgradeStartLease extends UpgradeOwnedDirectory {
}
export interface IVerifiedUpgradeWorkerProcessGroup {
    pid: number;
    processGroupId: number;
    fingerprint: string;
    cliPath: string;
}
export declare const terminateVerifiedUpgradeWorkerProcessGroup: (worker: IVerifiedUpgradeWorkerProcessGroup) => Promise<void>;
export declare class UpgradeCoordinator {
    readonly canonicalGlobalRoot: string;
    readonly uid: number;
    readonly baseDirectory: string;
    readonly upgradeLockDirectory: string;
    readonly startLeasesDirectory: string;
    readonly transactionsDirectory: string;
    readonly ownershipGuardsDirectory: string;
    private readonly usesLegacyLocation;
    private readonly usesInheritedLocation;
    private initializationTask?;
    constructor(canonicalGlobalRoot: string);
    init(): Promise<void>;
    initializeExistingCanonicalState(): Promise<void>;
    private performInitialization;
    inspectCanonicalTransactionInventory(): Promise<IUpgradeTransactionInventory>;
    private ownershipGuardDirectory;
    private inspectOwnershipGuardDirectory;
    private reclaimOwnershipGuardDirectory;
    private cleanupOwnershipGuardDirectories;
    private cleanupOwnershipGuardTemporaryDirectories;
    private acquireOwnershipMutationGuard;
    private withOwnershipMutationGuard;
    private reclaimStaleOwnedDirectory;
    private releaseOwnedDirectory;
    private inspectTransactionMutationDirectory;
    private reclaimStaleTransactionMutationDirectory;
    private inspectOwnedDirectory;
    private createOwnedDirectory;
    acquireUpgradeLock(optionsArg: {
        token: string;
        cliPath: string;
        command?: '__serve' | '__upgrade-worker' | 'upgrade' | 'foreground';
    }): Promise<UpgradeInstallationLock>;
    transferUpgradeLockToWorker(optionsArg: {
        lock: UpgradeInstallationLock;
        token: string;
        worker: NonNullable<TUpgradeTransaction['worker']>;
    }): Promise<void>;
    private readLiveUpgradeOwner;
    acquireStartLease(optionsArg: {
        token: string;
        cliPath: string;
        command: 'start' | 'foreground' | 'temp-password';
        upgradeToken?: string;
    }): Promise<UpgradeStartLease>;
    waitForStartLeasesToDrain(lockArg: UpgradeInstallationLock): Promise<void>;
    private tokenFilePath;
    private transactionFilePath;
    private transactionMutationDirectory;
    private withTransactionMutation;
    private cleanupUncommittedAdoptionAuditsUnderLock;
    adoptOrphanedTransaction(optionsArg: IAdoptOrphanedUpgradeTransactionOptions): Promise<TUpgradeTransaction>;
    createTransaction(optionsArg: {
        token: string;
        port: number;
        sourceVersion: string;
        registryUrl?: string;
        controllerWasRunning: boolean;
        continueSessions: boolean;
        gracePeriodMs: number;
    }): Promise<IUpgradeTransactionV2>;
    createPackageTransitionTransaction(optionsArg: {
        token: string;
        port: number;
        controllerWasRunning: boolean;
        continueSessions: boolean;
        gracePeriodMs: number;
    }): Promise<IUpgradeTransactionV3>;
    readTransaction(tokenArg: string): Promise<TUpgradeTransaction>;
    updateTransaction(tokenArg: string, expectedRevisionArg: number, updateArg: (currentArg: TUpgradeTransaction) => TUpgradeTransaction): Promise<TUpgradeTransaction>;
    mutateTransaction(tokenArg: string, updateArg: (currentArg: TUpgradeTransaction) => TUpgradeTransaction): Promise<TUpgradeTransaction>;
    private writeTransactionUpdate;
    registerWorker(tokenArg: string, cliPathArg: string): Promise<TUpgradeTransaction>;
    recordWorkerLaunch(tokenArg: string, pidArg: number, cliPathArg: string, logFilePathArg: string): Promise<TUpgradeTransaction>;
    recordController(tokenArg: string, controllerArg: TUpgradeTransaction['controller']): Promise<TUpgradeTransaction>;
    transactionControllerIsLive(transactionArg: TUpgradeTransaction): Promise<boolean>;
    transactionWorkerIsLive(transactionArg: TUpgradeTransaction): Promise<boolean>;
    terminateTransactionWorker(transactionArg: TUpgradeTransaction): Promise<void>;
    terminateUpgradeWorkerCandidate(worker: NonNullable<TUpgradeTransaction['worker']>): Promise<void>;
    readSanitizedUpgradeStatus(tokenArg: string): Promise<IControllerUpgradeStatus | undefined>;
    finishTransaction(tokenArg: string, successArg: boolean, messageArg: string, errorArg?: string): Promise<TUpgradeTransaction>;
    createLaunchGrant(optionsArg: {
        token: string;
        port: number;
        packageName: string;
        packageVersion: string;
        cliPath: string;
        controller: IUpgradeExpectedController;
    }): Promise<void>;
    removeLaunchGrant(tokenArg: string): Promise<void>;
    consumeLaunchGrant(optionsArg: {
        token: string;
        port: number;
        packageName: string;
        packageVersion: string;
        cliPath: string;
        controller: IUpgradeExpectedController;
    }): Promise<void>;
    private actionGrantFilePath;
    removeControllerActionGrant(actionArg: TUpgradeControllerAction, tokenArg: string): Promise<void>;
    createControllerActionGrant(optionsArg: {
        token: string;
        action: TUpgradeControllerAction;
        mode?: 'continue' | 'compensate' | 'reopen';
        packageVersion: string;
        controller: IUpgradeExpectedController;
    }): Promise<void>;
    consumeControllerActionGrant(optionsArg: {
        token: string;
        action: TUpgradeControllerAction;
        mode?: 'continue' | 'compensate' | 'reopen';
        packageVersion: string;
        controller: IUpgradeExpectedController;
    }): Promise<void>;
    removeWorkerAcknowledgement(tokenArg: string): Promise<void>;
    acknowledgeWorker(tokenArg: string, workerArg: Pick<IVerifiedUpgradeWorkerProcessGroup, 'pid' | 'processGroupId' | 'fingerprint'>): Promise<void>;
    waitForWorkerAcknowledgement(tokenArg: string, timeoutMsArg?: number): Promise<void>;
}
export declare const createUpgradeToken: () => string;
export declare const serializeUpgradeWorkerPayload: (payloadArg: IUpgradeWorkerPayload) => string;
export declare const parseUpgradeWorkerPayload: (payloadArg: unknown, tokenArg: unknown) => IUpgradeWorkerPayload;
export {};