import { ProvisionResult } from '../../provision/types.ts';
import { PathSpec } from '../../types.ts';
import type { TSNodeLike } from '../../shell/types.ts';
import type { ExecuteFn } from '../expand/node.ts';
import type { MountRegistry } from '../mount/registry.ts';
import type { Namespace } from '../mount/namespace/namespace.ts';
import type { Session } from '../session/session.ts';
interface ProvisionContext {
    registry: MountRegistry;
    executeFn: ExecuteFn;
    namespace?: Namespace | null;
    agentId?: string;
}
/**
 * Walk-local planner state. Function definitions seen during this
 * plan are recorded here (not on the session: planning must not
 * mutate shell state), and `planning` guards recursive functions
 * from looping the planner. `gated` hands the REDIRECT arm's
 * admission verdict (its classified words, keyed by the command
 * node) to the inner COMMAND arm: the run admits a redirected
 * command once, with its targets, so the plan must not consult
 * `preCommand` a second time for the same statement. Each entry is
 * deleted by the recursion that consumes it.
 */
interface PlanScope {
    functions: Map<string, TSNodeLike[]>;
    planning: Set<string>;
    gated: Map<TSNodeLike, (string | PathSpec)[]>;
}
/**
 * Walk tree-sitter AST and estimate execution cost.
 *
 * Dispatches on the same NodeKind classification as the executor
 * (`shell/node_kind.ts`), so every construct the executor runs has a
 * planner branch; kinds neither walker supports fall through to an
 * honest UNKNOWN.
 */
export declare function provisionNode(ctx: ProvisionContext, node: TSNodeLike | null | undefined, session: Session, scope?: PlanScope): Promise<ProvisionResult>;
export {};
//# sourceMappingURL=provision_node.d.ts.map