import { writeBlockedStepContract } from "audit-tools/shared";
import type { AnalyzerPolicy } from "audit-tools/shared";
import type { ExternalAcquisitionAdvanceOptions } from "../orchestrator/acquisitionExecutor.js";
import { renderSemanticReviewStep } from "./semanticReviewStep.js";
import { writeCurrentStep } from "./steps.js";
import type { NextStepResult } from "./nextStepHelpers.js";
export { tryConsumeSubmission, consumeArraySubmission, consumeObjectSubmission, renderDesignReviewRejectionNotice, renderEdgeReasoningRejectionNotice, buildTerminalStep, handleGraphEnrichmentBranch, handleDesignReviewBranch, handleSynthesisNarrativeBranch, executeAndRecord, checkFinalizationCycle, checkNoProgressBeforeDispatch, runDeterministicForNextStep, } from "./nextStepHelpers.js";
export declare function cmdNextStep(argv: string[]): Promise<void>;
/** What an emission row is given: the invocation's bindings plus its own result. */
interface NextStepEmitContext {
    argv: string[];
    root: string;
    artifactsDir: string;
    /**
     * The durable analyzer policy, loaded before any dispatch decision. Present
     * on every table-dispatched emission; the acquisition-bearing rows state that
     * dependence explicitly (see `requireLoadedAnalyzerPolicy`) instead of
     * assuming a caller loaded it.
     */
    analyzerPolicy: AnalyzerPolicy | null;
    result: NextStepResult;
}
/**
 * What to emit, never how to write it. Three writers exist (the step-contract
 * writer, the blocked-step writer, and the semantic-review renderer that
 * publishes the host workload), and each is called from exactly ONE place —
 * `writeAuditStep` — so the emit contract has a single edit site per writer.
 */
type AuditStepPlan = {
    via: "current";
    params: Parameters<typeof writeCurrentStep>[0];
} | {
    via: "blocked";
    params: Parameters<typeof writeBlockedStepContract>[0];
} | {
    via: "semantic_review";
    params: Parameters<typeof renderSemanticReviewStep>[0];
};
type NextStepEmissionKind = Exclude<NextStepResult["kind"], "semantic_review">;
type NextStepEmissionRow = (ctx: NextStepEmitContext) => Promise<AuditStepPlan>;
/**
 * The acquisition chokepoint's declared caller obligation, discharged in ONE
 * place: BOTH halves of the loaded policy ride every acquisition call — the
 * per-analyzer settings AND the recorded consent decisions. Dropping the
 * decisions leaves a recorded decline unrepresentable at admission (the
 * chokepoint would see `undefined` and read it as "not yet decided"), and no
 * consent token is synthesized here on the operator's behalf: the field is
 * absent, never an empty string.
 */
export declare function buildExternalAcquisitionOptions(policy: AnalyzerPolicy): ExternalAcquisitionAdvanceOptions;
/**
 * The step-emission dispatch table: exactly one row per host-actionable result
 * kind. Typed as a TOTAL record over the kind union, so a kind added upstream
 * with no row here is a compile error rather than a step that silently falls
 * through to the semantic-review dispatch.
 *
 * Exported together with the handled-kinds set below so a drift guard imports
 * the real thing instead of reconstructing it by reading a branch chain.
 */
export declare const NEXT_STEP_EMISSION_TABLE: Readonly<Record<NextStepEmissionKind, NextStepEmissionRow>>;
/**
 * The handled-kinds set, DERIVED from the table's own keys — never a second,
 * hand-listed copy that could disagree with the table it describes. A drift
 * guard consumes this as the real B side of its seam assertion.
 */
export declare const NEXT_STEP_EMISSION_KINDS: ReadonlySet<string>;
//# sourceMappingURL=nextStepCommand.d.ts.map