import type { ManagedProviderKind, ManagedProviderSpec } from "@termfleet/core/contracts/registry.js";
export type ProviderControlKind = ManagedProviderKind | "remote";
export type ProviderControlSpec = ManagedProviderSpec | {
    kind: "remote";
};
export type ProviderPhase = "down" | "failed" | "running" | "starting";
export type ProbeDeath = "definitive" | "indefinite";
export type ProbeResult = {
    alive: boolean;
    death?: ProbeDeath;
    message?: string;
    ready?: boolean;
};
export type ProviderStatus = {
    death?: ProbeDeath;
    lastProbedAt?: number;
    message?: string;
    phase: ProviderPhase;
    pid?: number;
};
export type DockerWorkerResources = {
    cpus?: string;
    memory?: string;
};
export type DesiredProvider = {
    aliases?: string[];
    baseUrl: string;
    label?: string;
    requiresAuth?: boolean;
    resources?: DockerWorkerResources;
    spec: ProviderControlSpec;
};
export type EnsureResult = {
    pid?: number;
};
export interface ProviderController {
    readonly kind: ProviderControlKind;
    ensure(target: DesiredProvider): Promise<EnsureResult>;
    probe(target: DesiredProvider): Promise<ProbeResult>;
    stop(target: DesiredProvider, pid: number | undefined): Promise<void>;
}
export type ProviderSupervisorOptions = {
    controllerFor: (kind: ProviderControlKind) => ProviderController | undefined;
    now?: () => number;
    onError?: (message: string) => void;
};
export type SupervisedProvider = {
    status: ProviderStatus;
    target: DesiredProvider;
};
export declare class ProviderSupervisor {
    private readonly controllerFor;
    private readonly inFlight;
    private readonly now;
    private readonly onError;
    private readonly recoveries;
    private readonly supervised;
    constructor(options: ProviderSupervisorOptions);
    ensure(target: DesiredProvider): Promise<ProviderStatus>;
    private runEnsure;
    reconcile(desired: DesiredProvider[]): Promise<void>;
    reconcileUnavailable(desired: DesiredProvider[]): Promise<void>;
    syncLiveness(desired: DesiredProvider[]): Promise<void>;
    stop(baseUrl: string): Promise<void>;
    isKnown(baseUrl: string): boolean;
    statusOf(baseUrl: string): ProviderStatus | undefined;
    knownOrigins(): string[];
    entries(): SupervisedProvider[];
    private set;
}
export declare function providerRecoveryDelayMs(attempts: number): number;
export declare function desiredFromSpec(record: {
    aliases?: string[];
    baseUrl: string;
    label?: string;
    lifecycle?: ManagedProviderSpec;
    requiresAuth?: boolean;
}): DesiredProvider | undefined;