import { type IControllerStatus } from '../dist_ts_interfaces/index.js';
import { requestControllerUpgradePrepareBegin, stopVerifiedController } from './classes.controllermanagement.js';
import { inspectControllerProcess, listControllerDataWriterProcessesForCliPaths } from './classes.processinspection.js';
import { type TUpgradeTransaction, type IUpgradeTransactionInventoryEntry, type IUpgradeExpectedController, type IUpgradeWorkerPayload, UpgradeCoordinator, type UpgradeInstallationLock } from './classes.upgradecoordinator.js';
export interface IPnpmGlobalInstallation {
    packageManagerPath: string;
    globalRoot: string;
    globalBinDirectory: string;
    packageDirectory: string;
    cliPath: string;
    packageVersion: string;
}
export interface IDetachedUpgradeWorker {
    pid: number;
    processGroupId: number;
    fingerprint: string;
    cliPath: string;
    logFilePath: string;
}
export interface IUpgradeWorkerLaunchCandidate {
    pid: number;
    cliPath: string;
    logFilePath: string;
    processGroupId?: number;
    fingerprint?: string;
}
export declare class UpgradeWorkerHandoffError extends Error {
    readonly recoveryLock: UpgradeInstallationLock;
    constructor(messageArg: string, causeArg: unknown, recoveryLock: UpgradeInstallationLock);
}
export declare class UpgradeWorkerCandidateDrainageError extends Error {
    constructor(messageArg: string, causeArg: unknown);
}
export interface ITerminalizeUpgradeWorkerHandoffFailureOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    error: UpgradeWorkerHandoffError;
}
export declare const terminalizeUpgradeWorkerHandoffFailure: (optionsArg: ITerminalizeUpgradeWorkerHandoffFailureOptions) => Promise<never>;
export declare const createPackageManagerEnvironment: (sourceArg?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
export declare const resolvePnpmGlobalInstallation: () => Promise<IPnpmGlobalInstallation>;
export declare const resolveInheritedUpgradeTargetInstallation: (transactionArg: TUpgradeTransaction) => Promise<IPnpmGlobalInstallation>;
export declare const resolveCurrentCliPath: () => Promise<string>;
export declare const resolveCurrentPnpmGlobalInstallation: () => Promise<IPnpmGlobalInstallation>;
export declare const tryResolveCurrentPnpmGlobalInstallation: () => Promise<IPnpmGlobalInstallation | undefined>;
export declare const compareSemver: (leftArg: string, rightArg: string) => number;
export interface IInspectOrphanedUpgradeForAdoptionOptions {
    coordinator: UpgradeCoordinator;
    installation: IPnpmGlobalInstallation;
    port: number;
    registryUrl?: string;
}
export declare const inspectOrphanedUpgradeForAdoption: (optionsArg: IInspectOrphanedUpgradeForAdoptionOptions) => Promise<IUpgradeTransactionInventoryEntry | undefined>;
export interface IAdoptOrphanedUpgradeUnderLockOptions extends IInspectOrphanedUpgradeForAdoptionOptions {
    lock: UpgradeInstallationLock;
    token: string;
    expected: IUpgradeTransactionInventoryEntry;
}
export interface IAdoptOrphanedUpgradeUnderLockDependencies {
    listDataWriterProcesses?: typeof listControllerDataWriterProcessesForCliPaths;
}
export declare const adoptOrphanedUpgradeUnderLock: (optionsArg: IAdoptOrphanedUpgradeUnderLockOptions, dependenciesArg?: IAdoptOrphanedUpgradeUnderLockDependencies) => Promise<TUpgradeTransaction>;
export interface ICandidateCleanupDependencies {
    beforeAttempt?: (processIdArg?: number) => Promise<void>;
}
export declare const terminateUpgradeWorkerCandidateUntilDrained: (coordinatorArg: UpgradeCoordinator, candidateArg: IDetachedUpgradeWorker) => Promise<void>;
interface ILaunchDetachedUpgradeWorkerOptions {
    installation: IPnpmGlobalInstallation;
    payload: IUpgradeWorkerPayload;
    environment?: NodeJS.ProcessEnv;
}
export declare function launchDetachedUpgradeWorker(optionsArg: ILaunchDetachedUpgradeWorkerOptions): Promise<IDetachedUpgradeWorker>;
declare const launchDetachedRecoveryWorker: (optionsArg: {
    installation: IPnpmGlobalInstallation;
    payload: IUpgradeWorkerPayload;
    environment?: NodeJS.ProcessEnv;
}) => Promise<IDetachedUpgradeWorker>;
export declare const authorizeUpgradeSourceStartup: (coordinatorArg: UpgradeCoordinator, tokenArg: string, portArg: number, sourceVersionArg: string) => Promise<TUpgradeTransaction>;
export interface IRetainedUpgradeTargetAuthorityOptions {
    coordinator: UpgradeCoordinator;
    token: string;
}
export interface IRetainedUpgradeTargetAuthorityDependencies {
    platform?: NodeJS.Platform;
    resolveInstallation?: (transactionArg: TUpgradeTransaction) => Promise<IPnpmGlobalInstallation>;
    inspectProcess?: typeof inspectControllerProcess;
}
export declare const retainedUpgradeTargetIsAuthoritative: (optionsArg: IRetainedUpgradeTargetAuthorityOptions, dependenciesArg?: IRetainedUpgradeTargetAuthorityDependencies) => Promise<boolean>;
export interface IWaitForControllerUpgradePreparationOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    targetVersion: string;
    gracePeriodMs: number;
    controllerIsLive: () => Promise<boolean>;
    now?: () => number;
    delay?: (millisecondsArg: number) => Promise<void>;
}
export declare const waitForControllerUpgradePreparation: (optionsArg: IWaitForControllerUpgradePreparationOptions) => Promise<TUpgradeTransaction>;
export interface IPrepareAndStopRunningControllerOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    port: number;
    targetVersion: string;
    gracePeriodMs: number;
    currentInstallation: IPnpmGlobalInstallation;
    runningStatus: IControllerStatus;
}
export interface IPrepareAndStopRunningControllerDependencies {
    requestPrepareBegin?: typeof requestControllerUpgradePrepareBegin;
    stopController?: typeof stopVerifiedController;
    controllerIsLive?: () => Promise<boolean>;
    now?: () => number;
    delay?: (millisecondsArg: number) => Promise<void>;
}
export declare const prepareAndStopRunningController: (optionsArg: IPrepareAndStopRunningControllerOptions, dependenciesArg?: IPrepareAndStopRunningControllerDependencies) => Promise<void>;
export declare const assertInheritedUpgradeTransaction: (transactionArg: TUpgradeTransaction, currentIdentityArg: {
    packageName: string;
    packageVersion: string;
    managementVersion: number;
    cliName: string;
    cliRelativePath: string;
}) => void;
export declare function runUpgradeWorker(payloadArg: IUpgradeWorkerPayload): Promise<void>;
interface IRecoverStalledUpgradeOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    transaction: TUpgradeTransaction;
    installation: IPnpmGlobalInstallation;
    command: '__serve' | 'foreground' | 'upgrade';
}
export interface IUpgradeWorkerHandoffDependencies {
    terminateWorkerCandidate?: (candidateArg: IDetachedUpgradeWorker) => Promise<void>;
    candidateCleanup?: ICandidateCleanupDependencies;
}
interface IRecoverStalledUpgradeDependencies extends IUpgradeWorkerHandoffDependencies {
    launchRecoveryWorker?: typeof launchDetachedRecoveryWorker;
}
export interface IHandoffLaunchedUpgradeWorkerUnderLockOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    installation: IPnpmGlobalInstallation;
    command: '__serve' | 'foreground' | 'upgrade';
    lock: UpgradeInstallationLock;
    candidate: IUpgradeWorkerLaunchCandidate;
    retainLockOnFailure?: boolean;
}
export declare const handoffLaunchedUpgradeWorkerUnderLock: (optionsArg: IHandoffLaunchedUpgradeWorkerUnderLockOptions, dependenciesArg?: IUpgradeWorkerHandoffDependencies) => Promise<IDetachedUpgradeWorker>;
export interface IHandoffStalledUpgradeRecoveryUnderLockOptions {
    coordinator: UpgradeCoordinator;
    token: string;
    installation: IPnpmGlobalInstallation;
    command: '__serve' | 'foreground' | 'upgrade';
    lock: UpgradeInstallationLock;
}
export declare const handoffStalledUpgradeRecoveryUnderLock: (optionsArg: IHandoffStalledUpgradeRecoveryUnderLockOptions, dependenciesArg?: IRecoverStalledUpgradeDependencies) => Promise<IDetachedUpgradeWorker | undefined>;
export declare function recoverStalledUpgrade(optionsArg: IRecoverStalledUpgradeOptions): Promise<boolean>;
export declare const createUpgradeWorkerPayload: (optionsArg: {
    port: number;
    gracePeriodMs: number;
    continueSessions: boolean;
    expectedController?: IUpgradeExpectedController;
}) => IUpgradeWorkerPayload;
export {};