/**
 * Discretion evaluation for CANT workflow conditionals.
 *
 * Discretion conditions (`**prose text**`) are AI-evaluated logic gates
 * in CANT workflows. The evaluation is pluggable: the default evaluator
 * stubs `true` (real LLM integration is a separate task), while custom
 * evaluators can be injected for testing, rule-based shortcuts, or
 * alternative model backends.
 *
 * @see docs/specs/CANT-DSL-SPEC.md Section 7.3 (Discretion Evaluation)
 */
import type { DiscretionContext } from './types.js';
/** Evaluates a discretion condition and returns a boolean judgment. */
export interface DiscretionEvaluator {
    /**
     * Evaluate whether a discretion condition is met.
     *
     * @param condition - The prose text between `**` delimiters.
     * @param context - Execution context including session, variables, and prior results.
     * @returns `true` if the condition is judged to be met.
     */
    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
}
/**
 * Default discretion evaluator that always returns `true`.
 *
 * This is a stub implementation. The real LLM-backed evaluator will be
 * implemented as a separate task. In production, this should be replaced
 * with an evaluator that:
 * - Calls the LLM API with the condition in a structured field
 * - Uses structured prompting (tool use / JSON mode)
 * - Returns a boolean judgment
 */
export declare class DefaultDiscretionEvaluator implements DiscretionEvaluator {
    /** Always returns `true` (stub). */
    evaluate(_condition: string, _context: DiscretionContext): Promise<boolean>;
}
/**
 * Mock discretion evaluator with configurable responses for testing.
 *
 * Responses can be set per condition text or as a blanket default.
 */
export declare class MockDiscretionEvaluator implements DiscretionEvaluator {
    private responses;
    private defaultResponse;
    private evaluationLog;
    /**
     * Creates a mock evaluator.
     *
     * @param defaultResponse - The response for conditions without a specific mapping.
     */
    constructor(defaultResponse?: boolean);
    /** Set the response for a specific condition text. */
    setResponse(condition: string, result: boolean): void;
    /** Evaluate using the configured response map. */
    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
    /** Get the log of all evaluations performed. */
    getLog(): ReadonlyArray<{
        condition: string;
        context: DiscretionContext;
        result: boolean;
    }>;
    /** Reset the evaluation log. */
    clearLog(): void;
}
/**
 * Wraps a discretion evaluator with rate limiting.
 *
 * Enforces a configurable maximum number of discretion evaluations per
 * workflow execution. Default limit is 100 per the spec. This prevents
 * runaway costs from loops containing discretion conditions.
 */
export declare class RateLimitedDiscretionEvaluator implements DiscretionEvaluator {
    private readonly inner;
    private readonly maxEvaluations;
    private evaluationCount;
    /**
     * Creates a rate-limited evaluator wrapper.
     *
     * @param inner - The underlying evaluator to delegate to.
     * @param maxEvaluations - Maximum evaluations allowed (default: 100).
     */
    constructor(inner: DiscretionEvaluator, maxEvaluations?: number);
    /**
     * Evaluate with rate limiting.
     *
     * @throws {Error} If the evaluation count exceeds the configured maximum.
     */
    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
    /** Get the current evaluation count. */
    getEvaluationCount(): number;
    /** Reset the evaluation counter (for reuse across workflow runs). */
    resetCount(): void;
}
//# sourceMappingURL=discretion.d.ts.map