import type { ExecutionContext } from "../../../schema/src/records/context.js";
import type { CoverageOutcome } from "../../../schema/src/records/coverage.js";
import type { Finding } from "../../../schema/src/records/finding.js";
import { type HarnessOutcome } from "../../../schema/src/records/harness.js";
import type { ContractStore } from "../contracts/store.js";
import { type DecisionStore } from "../decisions/store.js";
import { type ProvenancedEvidence } from "./certainty.js";
export type LaneEligibility = "blocking" | "blocking-eligible" | "advisory";
export type DetectorOutcome = {
    detector: {
        id: string;
        version: string;
    };
    class: string;
    severity: Finding["severity"];
    target: {
        kind: string;
        canonical: string;
    };
    context: ExecutionContext;
    summary: string;
    evidence: ProvenancedEvidence[];
    artifacts: Finding["artifacts"];
    laneEligibility: LaneEligibility;
    proofConditionMet?: boolean;
    scope: CoverageOutcome["scope"];
    violation: unknown;
    contractOrConfig?: unknown;
    contextDimensions?: Record<string, string>;
};
export type HarnessEvent = {
    phase: HarnessOutcome["phase"];
    scope: CoverageOutcome["scope"];
    plannedContext?: ExecutionContext;
    cause: HarnessOutcome["cause"];
    artifactRefs: Finding["artifacts"];
};
export type CoverageEvent = {
    scope: CoverageOutcome["scope"];
    context: ExecutionContext;
    reason: CoverageOutcome["reason"];
    witnessRefs: CoverageOutcome["witnessRefs"];
    capabilityProfileRef?: CoverageOutcome["capabilityProfileRef"];
    interaction?: CoverageOutcome["interaction"];
};
export type KernelStores = {
    decisions: DecisionStore;
    contracts: ContractStore;
    authoritativeContracts: ReadonlySet<string>;
    now: string;
};
export type ClassifyInput = {
    detectorOutcomes: DetectorOutcome[];
    harnessEvents: HarnessEvent[];
    coverageEvents: CoverageEvent[];
    stores: KernelStores;
    runId: string;
};
export type ClassifiedRun = {
    findings: Finding[];
    hiddenFindings: Finding[];
    coverageOutcomes: CoverageOutcome[];
    harnessOutcomes: HarnessOutcome[];
};
export type ClassifyEvidenceInput = Omit<DetectorOutcome, never> & {
    harnessEvents: HarnessEvent[];
    coverageEvents: CoverageEvent[];
    stores: KernelStores;
    runId: string;
};
export declare function queryClassifiedFindings(run: ClassifiedRun, options?: {
    audit?: boolean;
}): Finding[];
export declare function classify(input: ClassifyInput): ClassifiedRun;
export declare function classifyFromEvidence(inputs: ClassifyEvidenceInput[]): ClassifiedRun;
//# sourceMappingURL=classifier.d.ts.map