import type { RuntimeValidator } from '../validation/lightweight-validators';
import type { TypedExpressionContext, EvaluationResult, ValidationResult, ValidationError, ExpressionMetadata, EvaluationType, ExpressionCategory } from '../types/base-types';
export declare abstract class BaseExpressionImpl<TInput = unknown, TOutput = unknown> {
    abstract readonly name: string;
    abstract readonly category: ExpressionCategory;
    abstract readonly syntax: string;
    abstract readonly description: string;
    abstract readonly inputSchema: RuntimeValidator<TInput>;
    abstract readonly outputType: EvaluationType;
    abstract readonly metadata: ExpressionMetadata;
    protected trackPerformance(context: TypedExpressionContext, input: unknown, result: EvaluationResult<TOutput>, startTime: number): void;
    protected trackSimple(context: TypedExpressionContext, startTime: number, success: boolean, output?: unknown): void;
    protected toBoolean(value: unknown): boolean;
    protected success<T>(value: T, type: EvaluationResult<T>['type']): EvaluationResult<T>;
    protected failure<T>(name: string, type: ValidationError['type'], message: string, code: string, suggestions?: readonly string[] | string[]): EvaluationResult<T>;
    protected validationSuccess(): ValidationResult;
    protected validationFailure(type: ValidationError['type'], message: string, suggestions?: string[]): ValidationResult;
    protected isElement(value: unknown): value is Element;
    protected inferType(value: unknown): EvaluationResult<unknown>['type'];
    protected inferEvaluationType(value: unknown): EvaluationType;
    protected normalizeCollection(collection: unknown): unknown[];
    protected toNumber(value: unknown): number | null;
    abstract evaluate(context: TypedExpressionContext, input: TInput): Promise<EvaluationResult<TOutput>>;
    abstract validate(input: unknown): ValidationResult;
}
export declare function isBaseExpression(expr: unknown): expr is BaseExpressionImpl;
//# sourceMappingURL=base-expression.d.ts.map