import type { HyperScriptValue, EvaluationResult, TypedExpressionContext, TypedExpressionImplementation, ValidationResult, ExpressionCategory, ExpressionAnalysisInfo } from '../../types/command-types';
export declare const SymbolExpressionInputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
export type SymbolExpressionInput = any;
export declare class SymbolExpression implements TypedExpressionImplementation<HyperScriptValue, TypedExpressionContext> {
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly name = "symbol";
    readonly category: ExpressionCategory;
    readonly precedence = 18;
    readonly associativity: 'left' | 'right' | 'none';
    readonly outputType = "any";
    readonly analysisInfo: ExpressionAnalysisInfo;
    validate(args: unknown[]): Promise<ValidationResult>;
    evaluate(context: TypedExpressionContext, ...args: unknown[]): Promise<EvaluationResult<HyperScriptValue>>;
    private resolveSymbol;
    private inferType;
    getMetadata(): {
        name: string;
        category: "reference";
        version: string;
        description: string;
        inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
        supportedContexts: string[];
        performance: {
            complexity: string;
            averageExecutionTime: string;
            memoryUsage: string;
        };
        capabilities: {
            contextAware: boolean;
            supportsAsync: boolean;
            sideEffects: boolean;
            cacheable: boolean;
        };
    };
}
export declare function createSymbolExpression(): SymbolExpression;
export declare function isValidSymbolInput(args: unknown[]): args is SymbolExpressionInput;
export declare function resolveSymbol(symbolName: string, context: TypedExpressionContext): Promise<EvaluationResult<HyperScriptValue>>;
export default SymbolExpression;
//# sourceMappingURL=index.d.ts.map