import type { ASTNode, ExecutionContext } from '../types/core';
import type { ExecutionResult } from '../types/result';
export declare class BaseExpressionEvaluator {
    protected expressionRegistry: Map<string, any>;
    constructor();
    protected registerCategory(expressions: Record<string, any>): void;
    protected unwrapSelectorResult<T>(value: T | T[] | NodeList): T;
    evaluate(node: ASTNode, context: ExecutionContext): Promise<any>;
    evaluateWithResult(node: ASTNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
    protected evaluateArrayLiteral(node: any, context: ExecutionContext): Promise<any[]>;
    protected evaluateObjectLiteral(node: any, context: ExecutionContext): Promise<Record<string, any>>;
    protected evaluateConditionalExpression(node: any, context: ExecutionContext): Promise<any>;
    protected evaluateTemplateLiteral(node: any, context: ExecutionContext): Promise<string>;
    protected evaluateSimpleExpression(exprCode: string, context: ExecutionContext): Promise<any>;
    protected resolveValue(name: string, context: ExecutionContext): Promise<any>;
    protected evaluateIdentifier(node: {
        name: string;
        scope?: 'local' | 'global';
    }, context: ExecutionContext): Promise<any>;
    protected evaluateLiteral(node: {
        value: any;
    }, _context: ExecutionContext): Promise<any>;
    protected evaluateContextReference(node: {
        contextType: string;
        name: string;
    }, context: ExecutionContext): Promise<any>;
    protected evaluateMemberExpression(node: any, context: ExecutionContext): Promise<any>;
    private coerceArithmeticOperand;
    protected evaluateBinaryExpression(node: any, context: ExecutionContext): Promise<any>;
    protected evaluateUnaryExpression(node: any, context: ExecutionContext): Promise<any>;
    protected evaluateCallExpression(node: any, context: ExecutionContext): Promise<any>;
    private evaluateMethodCall;
    protected evaluateSelector(node: {
        value: string;
    }, context: ExecutionContext): Promise<HTMLElement[]>;
    protected evaluateAttributeAccess(node: {
        attributeName: string;
    }, context: ExecutionContext): string | boolean | null;
    getAvailableExpressions(): string[];
    protected evaluateDollarExpression(node: {
        expression: any;
    }, context: ExecutionContext): Promise<any>;
    protected evaluatePossessiveExpression(node: any, context: ExecutionContext): Promise<any>;
    hasExpression(name: string): boolean;
    protected evaluateCSSSelector(node: {
        selectorType: string;
        selector: string;
    }, context: ExecutionContext): Promise<HTMLElement | HTMLElement[] | null>;
    protected evaluateIdSelector(node: {
        value: string;
    }, context: ExecutionContext): Promise<Element | null>;
    protected evaluateQueryReference(node: {
        selector: string;
    }, context: ExecutionContext): Promise<NodeList>;
    protected evaluatePropertyAccess(node: {
        object: ASTNode;
        property: {
            name?: string;
            value?: string;
        };
    }, context: ExecutionContext): Promise<any>;
    protected evaluatePropertyOfExpression(node: {
        property: {
            name?: string;
            value?: string;
        };
        target: ASTNode;
    }, context: ExecutionContext): Promise<any>;
}
//# sourceMappingURL=base-expression-evaluator.d.ts.map