import * as Effect from "effect/Effect";
import { type ConfirmationRecovery, type ConfirmationRecoveryArgument, type PlanExecution, type RequestedPlanIntent, type ResolvedUnit, type PlanPolicyId } from "@agentxm/workspace-kernel/operations";
import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
export declare const makeConfirmationRecovery: (command: ReadonlyArray<string>, arguments_: ReadonlyArray<ConfirmationRecoveryArgument>) => ConfirmationRecovery;
/**
 * What one invocation hands the kernel, and what it keeps to name itself.
 *
 * The execution carries the parsed intent; the recovery is the invocation as
 * every recovery line replays it — the route's own arguments followed by the
 * explicit global flags — and is the one value the kernel's command renderer
 * reads, whether the line asks for approval, a policy override, or a retry.
 */
export interface PlanInvocation {
    readonly execution: PlanExecution;
    readonly recovery: ConfirmationRecovery;
}
/**
 * The parsed intent a route registered, handed to the one derivation that
 * owns it. `yes` reaches this function only from the routes whose
 * capabilities declare a preapprovable confirmation and therefore register
 * `--yes`; the derivation in `workspace-operations` decides what a preview
 * and an apply each do with it, so no downstream planner sees the raw flag.
 */
export declare const makePlanInvocation: (intent: RequestedPlanIntent, recovery: ConfirmationRecovery, acceptedPolicies?: ReadonlyArray<PlanPolicyId>) => Effect.Effect<PlanInvocation>;
export declare const makePublicPositionalPlanInvocation: (intent: RequestedPlanIntent, command: ReadonlyArray<string>, positionals: ReadonlyArray<string>, acceptedPolicies?: ReadonlyArray<PlanPolicyId>) => Effect.Effect<PlanInvocation>;
export declare const makeInstallPlanInvocation: (intent: RequestedPlanIntent & {
    readonly force?: boolean;
}, command: ReadonlyArray<string>, locators: ReadonlyArray<string>, arguments_?: ReadonlyArray<ConfirmationRecoveryArgument>) => Effect.Effect<PlanInvocation>;
/**
 * The retry a route offers for the units that did not settle: the invocation
 * replayed as the kernel renders it. A recovery whose values cannot be echoed
 * safely is described without a command, exactly as an approval recovery is.
 */
export declare const retrySuggestion: (description: string, recovery: ConfirmationRecovery) => SuggestedAction;
/**
 * An install replayed for the units that did not settle. An invocation that
 * selected extensions from its source — by `--all` or by name — selects only
 * the waiting ones on the retry; one that selected nothing, or whose waiting
 * units are not extensions the selectors can name, is replayed as typed, and
 * the units it already settled converge as no-ops.
 */
export declare const narrowInstallSelection: (recovery: ConfirmationRecovery, unsettled: ReadonlyArray<ResolvedUnit<unknown>>) => ConfirmationRecovery;
/**
 * A typed update replayed for the units that did not settle: the `--name`
 * selectors it carried give way to the names still waiting. A sweep whose
 * waiting units are not extensions a name can select is replayed as typed.
 */
export declare const narrowUpdateNames: (recovery: ConfirmationRecovery, unsettled: ReadonlyArray<ResolvedUnit<unknown>>) => ConfirmationRecovery;
//# sourceMappingURL=confirmation-recovery.d.ts.map