import type { RuleNamespace, EvaluationContext, EvaluationResult } from './types.js';
/**
 * Rule evaluator class
 */
export declare class RuleEvaluator {
    private namespaces;
    /**
     * Register a rule namespace
     */
    registerNamespace(namespace: RuleNamespace): void;
    /**
     * Unregister a rule namespace
     */
    unregisterNamespace(name: string): void;
    /**
     * Evaluate all applicable rules against the context
     */
    evaluate(context: EvaluationContext): Promise<EvaluationResult>;
    /**
     * Get rules that apply to the given context
     */
    private getApplicableRules;
    /**
     * Check if a rule's conditions match the context
     */
    private ruleMatches;
    /**
     * Evaluate a single condition expression
     */
    private evaluateCondition;
    /**
     * Resolve a field path to its value in the context
     */
    private resolveField;
    /**
     * Evaluate a single rule against the context
     */
    private evaluateRule;
    /**
     * Safely evaluate a condition expression string
     *
     * Uses the secure expression evaluator that supports:
     * - Logical operators: AND, OR, NOT (or &&, ||, !)
     * - Comparison operators: ==, !=, <, >, <=, >=
     * - String operations: contains(), startsWith(), endsWith(), matches()
     * - Arithmetic: +, -, *, /, %
     * - Variable interpolation from context (e.g., entity.trustLevel, intent.goal)
     * - Nested expressions with parentheses
     *
     * @param expression - The expression string to evaluate
     * @param context - The evaluation context
     * @returns boolean result of the expression
     * @throws ExpressionError on invalid expressions
     */
    private evaluateExpressionSafe;
    /**
     * Determine the final action from all rule results
     */
    private determineFinalAction;
}
/**
 * Create a new rule evaluator instance
 */
export declare function createEvaluator(): RuleEvaluator;
//# sourceMappingURL=evaluator.d.ts.map