import { z } from 'zod';
import type { RuleCategory, RuleDepth } from '../checkRules.js';
import type { VisualizerSpec } from '../visualizerModel.js';
export { VisualizerSpecSchema } from '../visualizerModel.js';
export type { VisualizerSpec } from '../visualizerModel.js';
export interface Relation {
    type: 'blocks' | 'blocked-by' | 'relates';
    issueId: string;
}
export interface Source {
    id: string;
    kind: string;
    ref?: string;
    content?: string;
}
export interface Proof {
    explanation: string;
    evidenceRefs: string[];
}
export interface BlockRef {
    issue: string;
    ac?: string;
}
export declare const PRIMITIVES: readonly ["labels", "relations", "children", "sources", "category", "proof", "blocking", "audit"];
export type PrimitiveName = (typeof PRIMITIVES)[number];
export interface CoreEvidence {
    id: string;
}
export interface CoreAC {
    id: string;
    status: string;
    evidence: CoreEvidence[];
    category?: string;
    proof?: Proof;
    blockedBy?: BlockRef[];
    blocks?: BlockRef[];
}
export interface CoreIssue {
    id: string;
    title: string;
    summary: string;
    status: string;
    acceptanceCriteria: CoreAC[];
    labels?: string[];
    relations?: Relation[];
    children?: string[];
    sources?: Source[];
}
export interface CoreRoot {
    issues: CoreIssue[];
}
export interface Origin {
    path: string;
    lineStart?: number;
    lineEnd?: number;
}
export interface IssueRecord {
    id: string;
    title: string;
    status: string;
    assignee?: string;
    labels?: string[];
    children?: string[];
    body: string;
    origin?: Origin;
}
export interface IssueColumns {
    title?: string;
    status?: string;
    assignee?: string;
    labels?: string[];
    children?: string[];
}
export interface WaiverDirective {
    issueId: string;
    code: string;
    reason: string;
    approvedBy: string;
    acId?: string;
    ref?: string;
}
export interface AuditEntry {
    ts: string;
    issueId: string;
    op: string;
    field?: string;
    from?: string;
    to?: string;
    actor?: string;
}
export type Severity = 'error' | 'warning' | 'acknowledged';
export interface Finding {
    code: string;
    severity: Severity;
    message: string;
    issueId?: string;
    acId?: string;
    evidenceId?: string;
    subject?: string;
    waivable?: boolean;
    fix?: string;
    origin?: FindingOrigin;
}
export interface FindingOrigin {
    path: string;
    line?: number;
}
export interface ParseDiagnostic {
    code: string;
    severity?: 'error' | 'warning';
    message: string;
    issueId?: string;
}
export interface Context {
    now?: string;
    phase?: 'all' | 'gate';
    git?: {
        currentSha?: string;
        existingCommits?: string[];
        prs?: Record<string, {
            headSha?: string;
            merged?: boolean;
        }>;
        branches?: Record<string, string>;
        evidenceBlobs?: Record<string, boolean>;
        commitFiles?: Record<string, string[]>;
    };
    world?: {
        events?: readonly {
            id: string;
            service: string;
            type?: string;
            text?: string;
            annotationRequired?: boolean;
        }[];
        annotations?: readonly {
            id: string;
            service?: string;
            eventId: string;
            classification: 'source' | 'noise' | 'duplicate';
            quote?: string;
        }[];
    };
    categories?: Partial<Record<RuleCategory, number>>;
    relevance?: 'optional' | 'required';
    waivers?: WaiverDirective[];
}
export declare const CoreContextSchema: z.ZodObject<{
    now: z.ZodOptional<z.ZodString>;
    phase: z.ZodOptional<z.ZodEnum<{
        all: "all";
        gate: "gate";
    }>>;
    git: z.ZodOptional<z.ZodObject<{
        currentSha: z.ZodOptional<z.ZodString>;
        existingCommits: z.ZodOptional<z.ZodArray<z.ZodString>>;
        prs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            headSha: z.ZodOptional<z.ZodString>;
            merged: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>>>;
        branches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        evidenceBlobs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        commitFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
    }, z.core.$strict>>;
    world: z.ZodOptional<z.ZodObject<{
        events: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            service: z.ZodString;
            type: z.ZodOptional<z.ZodString>;
            text: z.ZodOptional<z.ZodString>;
            annotationRequired: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>>>;
        annotations: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            service: z.ZodOptional<z.ZodString>;
            eventId: z.ZodString;
            classification: z.ZodEnum<{
                source: "source";
                noise: "noise";
                duplicate: "duplicate";
            }>;
            quote: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    relevance: z.ZodOptional<z.ZodEnum<{
        optional: "optional";
        required: "required";
    }>>;
    waivers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        issueId: z.ZodString;
        code: z.ZodString;
        reason: z.ZodString;
        approvedBy: z.ZodString;
        acId: z.ZodOptional<z.ZodString>;
        ref: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
}, z.core.$strict>;
/** The ONE top-level schema: ValidationInput = { context, root }, both strict. A
 *  preset may pass an extended contextSchema for its own observed facts. */
export declare function makeValidationInputSchema<R extends CoreRoot>(rootSchema: z.ZodType<R>, contextSchema?: z.ZodTypeAny): z.ZodType<ValidationInput<R>>;
export interface ValidationInput<R extends CoreRoot> {
    context: Context;
    root: R;
}
export interface Located {
    issueId?: string;
    acId?: string;
    evidenceId?: string;
}
export interface ModelIssue<R extends CoreRoot> {
    issueId: string;
    issue: R['issues'][number];
}
export interface ModelAC<R extends CoreRoot> {
    issueId: string;
    acId: string;
    issue: R['issues'][number];
    ac: R['issues'][number]['acceptanceCriteria'][number];
}
export interface ModelEvidence<R extends CoreRoot> extends ModelAC<R> {
    evidenceId: string;
    ev: R['issues'][number]['acceptanceCriteria'][number]['evidence'][number];
}
export interface CycleFact extends Located {
    issueId: string;
    cycle: string[];
}
export interface BlockerFact extends Located {
    issueId: string;
    acId: string;
    kind: 'missing' | 'self';
    refText: string;
}
export interface CompletionFact extends Located {
    issueId: string;
    nodeKey: string;
    depKey: string;
    depStatus: string;
}
export interface DerivedModel<R extends CoreRoot> {
    root: R;
    context: Context;
    issues: Array<ModelIssue<R>>;
    acs: Array<ModelAC<R>>;
    evidence: Array<ModelEvidence<R>>;
    duplicateIssueIds: Array<{
        issueId: string;
    }>;
    duplicateAcIds: Array<{
        issueId: string;
        acId: string;
    }>;
    graph: {
        cycles: CycleFact[];
        blockerProblems: BlockerFact[];
        completionViolations: CompletionFact[];
    };
    derived: Record<string, Located[]>;
}
export interface RuleRecord<R extends CoreRoot, Item extends Located = Located> {
    code: string;
    severity?: Severity;
    phase?: 'gate' | 'transition';
    state?: string | string[];
    category?: RuleCategory;
    depth?: RuleDepth;
    waivable?: boolean;
    select: (m: DerivedModel<R>) => Item[];
    when?: (item: Item, m: DerivedModel<R>) => boolean;
    message: (item: Item, m: DerivedModel<R>) => string;
    subject?: (item: Item, m: DerivedModel<R>) => string;
}
export type Rule<R extends CoreRoot> = RuleRecord<R, Located>;
/** Authoring helper: infers the selected item type so `when`/`message` are typed,
 *  while storing as the existential `Rule<R>` a preset's `rules` array holds. */
export declare function rule<R extends CoreRoot, Item extends Located>(r: RuleRecord<R, Item>): Rule<R>;
/** The blessed preset constructor a repo-local preset calls — today an identity, but a
 *  stable seam so installed presets read `definePreset({...})` and we can add inference
 *  or validation later without breaking them. */
export declare function definePreset<R extends CoreRoot>(preset: Preset<R>): Preset<R>;
export interface PresetContextInput {
    projectRoot: string;
    verifyCommits?: boolean;
    bundle?: string;
    root?: CoreRoot;
}
export interface Preset<R extends CoreRoot> {
    name: string;
    schema: z.ZodType<R>;
    contextSchema?: z.ZodTypeAny;
    loadContext?: (input: PresetContextInput) => Context | Promise<Context>;
    parse: (records: IssueRecord[]) => unknown;
    serialize?: (issue: R['issues'][number]) => {
        body: string;
        columns: IssueColumns;
    };
    normalizeAcPatch?: (patch: Record<string, unknown>, current: Record<string, unknown>) => Record<string, unknown>;
    rules: Rule<R>[];
    derive?: (model: DerivedModel<R>) => Record<string, Located[]>;
    isIssueDone?: (issue: R['issues'][number]) => boolean;
    primitives?: Partial<Record<PrimitiveName, boolean>>;
    scaffold?: (title: string) => string;
    fixHint?: (finding: Finding) => string | undefined;
    visualizer?: VisualizerSpec;
}
export interface CheckResult<R extends CoreRoot> {
    ok: boolean;
    findings: Finding[];
    export?: R;
    examinedIssues?: number;
}
export declare function deriveCoreModel<R extends CoreRoot>(root: R, context: Context, isIssueDone?: (issue: R['issues'][number]) => boolean): DerivedModel<R>;
export declare function parseWaiverLine(line: string): {
    code: string;
    acId?: string;
    ref?: string;
    reason: string;
    approvedBy: string;
} | null;
export declare function parseWaivers(records: IssueRecord[]): WaiverDirective[];
export declare function liftDiagnostics(candidate: unknown, originById?: Map<string, Origin>): {
    root: unknown;
    findings: Finding[];
};
/** The one entry point: parse -> ValidationInputSchema.parse({context, root}) ->
 *  pure rules. The validated Root is the export; nothing downstream re-parses or
 *  re-derives. */
export declare function check<R extends CoreRoot>(preset: Preset<R>, records: IssueRecord[], ctx?: Context): CheckResult<R>;
/** Validate an already-parsed Root (the exported, validated model) against the same
 *  schema + rules — the entry point for `check --input <root.json>` and CI. */
export declare function checkRoot<R extends CoreRoot>(preset: Preset<R>, root: unknown, ctx?: Context): CheckResult<R>;