type Json = any;
export interface Proposal {
    ability_id: string;
    name: string;
    faction: string;
    effect_type?: string;
    complex?: boolean;
    confidence?: "high" | "medium" | "low";
    schema_valid: boolean;
    proposed_effect?: Json;
    proposed_scope?: Json;
    /** Ability-level behavior the repair pass inferred (passive/activated/reactive/aura). */
    proposed_behavior?: string;
    verdict?: {
        severity: string;
        faithful: boolean;
        issue: string;
    } | null;
    final_faithful: boolean;
    error?: string;
    /** Set by the full-tree repair pass — the effect is a nested tree, not flat-form. */
    repaired?: boolean;
    /** Repair pass flagged this rule as genuinely unencodable (needs hand-authoring). */
    unencodable?: boolean;
    /** Canonical-key lint result (repair pass only). false = invented/out-of-vocab modifier keys. */
    canonical?: boolean;
}
/** One batched, structured `claude -p` call. Resolves to the validated object. */
export declare function callClaude(system: string, user: string, schema: Json, model: string): Promise<Json>;
export declare const VERIFY_SYSTEM: string;
export declare const VERIFY_SCHEMA: {
    type: string;
    additionalProperties: boolean;
    properties: {
        results: {
            type: string;
            items: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    ability_id: {
                        type: string;
                    };
                    severity: {
                        enum: string[];
                    };
                    faithful: {
                        type: string;
                    };
                    issue: {
                        type: string;
                    };
                };
                required: string[];
            };
        };
    };
    required: string[];
};
export declare const REPAIR_SYSTEM: string;
export declare const REPAIR_SCHEMA: {
    type: string;
    additionalProperties: boolean;
    properties: {
        results: {
            type: string;
            items: {
                type: string;
                additionalProperties: boolean;
                properties: {
                    ability_id: {
                        type: string;
                    };
                    effect: {
                        type: string;
                        additionalProperties: boolean;
                    };
                    scope: {
                        type: string;
                        additionalProperties: boolean;
                    };
                    behavior: {
                        type: string;
                    };
                    unencodable: {
                        type: string;
                    };
                    confidence: {
                        enum: string[];
                    };
                    reasoning: {
                        type: string;
                    };
                };
                required: string[];
            };
        };
    };
    required: string[];
};
export declare function conditionNode(kind: string, param: string | null | undefined): Json | null;
/** Build the effect node + scope from a flat-form. */
export declare function assembleEffect(form: Json): {
    effect: Json;
    scope: Json;
};
/** Splice the authored effect+scope onto the original entry, preserving metadata. */
export declare function buildEntry(original: Json, form: Json): Json;
/**
 * Walk an effect tree and flag any cruncher-interpreted leaf whose modifier
 * carries an unknown key or an out-of-vocabulary stat/roll/subset/attack_type.
 * Non-interpreted leaf types (ability-grant, movement-modifier, …) are left
 * permissive — they don't reach the damage path, so an unknown key there is a
 * consistency nit, not a silent-corruption risk.
 */
export declare function lintCanonical(effect: Json): {
    canonical: boolean;
    issues: string[];
};
/**
 * Splice a pre-formed nested effect tree (from the repair pass) onto the original
 * entry. Unlike {@link buildEntry} the LLM owns the whole tree, so we only graft
 * `effect`/`scope`/`behavior` and the citation — never the flat-form assembly.
 * `behavior` is an ability-level field; only set it when the model returned a
 * valid enum value (an invalid one would just fail AJV and lose the whole entry).
 */
export declare function buildRepairedEntry(original: Json, effect: Json, scope: Json, behavior?: string): Json;
export interface GateOpts {
    minConfidence: "high" | "medium";
    includeComplex: boolean;
}
/** Whether a proposal is safe to apply automatically. */
export declare function passesGate(p: Proposal, opts: GateOpts): boolean;
export declare const verifyUserPrompt: (entries: {
    ability_id: string;
    rule: string;
    effect: Json;
    scope: Json;
}[]) => string;
export declare const repairUserPrompt: (items: {
    ability_id: string;
    rule: string;
    draft: Json;
    issue: string;
}[]) => string;
export {};
//# sourceMappingURL=author-batch.d.ts.map