import { type CliRuntime } from "@velum-labs/routekit-cli-core";
import { RouteKitFailure, type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
import { Effect } from "effect";
import { type ProvisionResult, type ProvisionStepId, provisionRemoteHost } from "../../remote-provision.js";
import type { RemoteStores } from "../../repositories/stores.js";
import type { RemoteEnrollmentJournal, RemoteRemovalJournal, RemoteTransactionJournal } from "../../repositories/remote-transaction-journal.js";
import { type RouteKitRemote } from "../../remotes.js";
export type EnrolledRemote = RouteKitRemote & {
    active: boolean;
    token: "stored";
    healthy: true;
    remoteVersion?: string;
    protocol?: string;
};
export type EnrollmentResult = {
    remote: EnrolledRemote;
    versionMismatch?: string;
};
export type RemoteEnrollmentTransactionPorts = {
    writeJournal(journal: RemoteEnrollmentJournal): void;
    clearJournal(): void;
    writeCredential(name: string, token: string): Promise<void>;
    commitRegistry(remote: RouteKitRemote, activate: boolean): void;
    restoreRegistry(): void;
    restoreCredential(): Promise<void>;
    revoke(remote: RouteKitRemote, tokenId: string): Effect.Effect<void, Error, RouteKitPlatform>;
    recordCompensation(remote: string, tokenId: string, reason: string): void;
};
/** Unit of work for one issued remote token and its local enrollment commit. */
export declare class RemoteEnrollmentTransaction {
    #private;
    constructor(input: {
        name: string;
        activate: boolean;
    }, ports: RemoteEnrollmentTransactionPorts);
    stage(remote: RouteKitRemote, issued: {
        id: string;
        token: string;
    }, journal?: RemoteEnrollmentJournal): RouteKitRemote;
    commit(): Effect.Effect<RouteKitRemote, RouteKitFailure | AggregateError, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
    rollback(error: unknown): Effect.Effect<never, RouteKitFailure | AggregateError, never>;
}
export declare class EnrollRemote {
    private readonly stores;
    private readonly runtime;
    constructor(stores: RemoteStores, runtime?: CliRuntime);
    execute(input: {
        name: string;
        gatewayUrl: string;
        sshHost: string;
        use: boolean;
    }): Effect.Effect<{
        versionMismatch?: string | undefined;
        remote: {
            protocol?: string | undefined;
            remoteVersion?: string | undefined;
            active: boolean;
            token: "stored";
            healthy: true;
            name: string;
            gatewayUrl: string;
            sshHost: string;
            addedAt: string;
            tokenId: string;
        };
    }, Error, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
}
export declare class RemoveRemote {
    private readonly stores;
    constructor(stores: RemoteStores);
    execute(name: string): Effect.Effect<{
        name: string;
        removed: true;
    }, Error, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
}
export type ProvisionRemoteResult = {
    provisioned: ProvisionResult;
    enrolled?: EnrollmentResult;
};
export type RemoteRemovalTransactionPorts = {
    writeJournal(journal: RemoteRemovalJournal): void;
    clearJournal(): void;
    journal: RemoteRemovalJournal;
    commitRegistry(): void;
    deleteCredential(): Promise<void>;
    revokeRemote(): Effect.Effect<void, Error, RouteKitPlatform>;
    restoreLocal(): Promise<void>;
};
/** Removes local authority first and restores it if remote revocation fails. */
export declare class RemoteRemovalTransaction {
    private readonly ports;
    constructor(ports: RemoteRemovalTransactionPorts);
    commit(): Effect.Effect<void, Error, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
}
export type RemoteTransactionRecoveryPorts = {
    readJournal(): RemoteTransactionJournal | undefined;
    currentRegistry(): ReturnType<RemoteStores["registry"]["read"]>;
    restoreRegistry(snapshot: ReturnType<RemoteStores["registry"]["snapshot"]>): void;
    readCredential(name: string): Promise<string | undefined>;
    writeCredential(name: string, token: string): Promise<void>;
    deleteCredential(name: string): Promise<void>;
    clearJournal(): void;
    revoke(remote: RouteKitRemote, tokenId: string): Effect.Effect<void, Error, RouteKitPlatform>;
    recordCompensation(remote: string, tokenId: string, reason: string): void;
};
export declare function recoverRemoteTransaction(ports: RemoteTransactionRecoveryPorts): Effect.Effect<"none" | "completed" | "rolled-back", Error | RouteKitFailure, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
export declare class ProvisionRemote {
    private readonly enrollment;
    constructor(enrollment: EnrollRemote);
    execute(input: {
        sshHost: string;
        version: string;
        force: boolean;
        dryRun: boolean;
        enrollment?: {
            name: string;
            gatewayUrl: string;
            use: boolean;
        };
        onStepStart?: (id: ProvisionStepId) => void;
        onStep?: Parameters<typeof provisionRemoteHost>[0]["onStep"];
    }): Effect.Effect<{
        enrolled?: {
            versionMismatch?: string | undefined;
            remote: {
                protocol?: string | undefined;
                remoteVersion?: string | undefined;
                active: boolean;
                token: "stored";
                healthy: true;
                name: string;
                gatewayUrl: string;
                sshHost: string;
                addedAt: string;
                tokenId: string;
            };
        } | undefined;
        provisioned: ProvisionResult;
    }, Error, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
}