import type { EvaluationContext } from './types.js';
/**
 * Configuration for expression evaluation limits
 */
export interface ExpressionConfig {
    /** Maximum depth for nested expressions (default: 10) */
    maxDepth?: number;
    /** Maximum expression length in characters (default: 1000) */
    maxLength?: number;
    /** Timeout in milliseconds (default: 100ms) */
    timeoutMs?: number;
}
/**
 * Expression evaluation error
 */
export declare class ExpressionError extends Error {
    position?: number;
    expression?: string;
    constructor(message: string, position?: number, expression?: string);
}
/**
 * Evaluate an expression string against a context
 *
 * @param expression - The expression string to evaluate
 * @param context - The evaluation context containing variables
 * @param config - Optional configuration for limits
 * @returns The result of evaluating the expression (coerced to boolean for rule evaluation)
 */
export declare function evaluateExpression(expression: string, context: EvaluationContext, config?: ExpressionConfig): boolean;
/**
 * Validate an expression without evaluating it
 *
 * @param expression - The expression to validate
 * @param config - Optional configuration for limits
 * @returns Validation result with any errors
 */
export declare function validateExpression(expression: string, config?: ExpressionConfig): {
    valid: boolean;
    errors: string[];
};
/**
 * Get detailed evaluation result (for debugging)
 *
 * @param expression - The expression to evaluate
 * @param context - The evaluation context
 * @param config - Optional configuration
 * @returns Detailed result including the raw value
 */
export declare function evaluateExpressionDetailed(expression: string, context: EvaluationContext, config?: ExpressionConfig): {
    success: boolean;
    value: unknown;
    booleanResult: boolean;
    error?: string;
};
//# sourceMappingURL=expression-evaluator.d.ts.map