import { type CliRuntime } from "@velum-labs/routekit-cli-core";
import { RouteKitFailure, type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
import { Context, Effect, Layer } from "effect";
import { LegacySecretImportRequiresLoginError } from "../../adapters/darwin-legacy-secret-importer.js";
import { 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 RemoteEnrollmentTransactionPorts = {
    writeJournal(journal: RemoteEnrollmentJournal): void;
    clearJournal(): void;
    writeCredential(name: string, token: string): Effect.Effect<void, Error>;
    commitRegistry(remote: RouteKitRemote, activate: boolean): void;
    restoreRegistry(): void;
    restoreCredential(): Effect.Effect<void, Error>;
    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, Error | AggregateError, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
    rollback(error: unknown): Effect.Effect<never, RouteKitFailure | AggregateError, never>;
}
export declare const RemoteCliPlatform: Context.Service<{
    readonly stores: RemoteStores;
    readonly runtime: CliRuntime;
}, {
    readonly stores: RemoteStores;
    readonly runtime: CliRuntime;
}>;
declare const Remote_base: Context.ServiceClass<Remote, "RouteKitCli/Remote", {
    enroll: (input: Parameters<(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>>[0]) => 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, never>;
    remove: (name: string) => Effect.Effect<{
        name: string;
        removed: true;
    }, Error | LegacySecretImportRequiresLoginError, never>;
    provision: (input: Parameters<(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: import("../../remote-provision.js").ProvisionResult;
    }, Error, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>>[0]) => 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: import("../../remote-provision.js").ProvisionResult;
    }, Error, never>;
}>;
export declare class Remote extends Remote_base {
    static readonly layer: Layer.Layer<Remote, never, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices | {
        readonly stores: RemoteStores;
        readonly runtime: CliRuntime;
    }>;
}
export type RemoteRemovalTransactionPorts = {
    writeJournal(journal: RemoteRemovalJournal): void;
    clearJournal(): void;
    journal: RemoteRemovalJournal;
    commitRegistry(): void;
    deleteCredential(): Effect.Effect<void, Error>;
    revokeRemote(): Effect.Effect<void, Error, RouteKitPlatform>;
    restoreLocal(): Effect.Effect<void, Error>;
};
/** 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): Effect.Effect<string | undefined, Error>;
    writeCredential(name: string, token: string): Effect.Effect<void, Error>;
    deleteCredential(name: string): Effect.Effect<void, Error>;
    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, import("effect/unstable/http/HttpClient").HttpClient | import("@effect/platform-node/NodeServices").NodeServices>;
export {};