import type { ValidationResult, TypedExecutionContext, TypedResult as TypedResult, LLMDocumentation as LLMDocumentation, EvaluationType as EvaluationType, ExpressionMetadata as ExpressionMetadata, ExpressionCategory as ExpressionCategory } from '../../types/index';
interface BaseTypedExpression<T> {
    readonly name: string;
    readonly category: string;
    readonly syntax: string;
    readonly outputType: EvaluationType;
    readonly inputSchema: any;
    readonly metadata: ExpressionMetadata;
    readonly documentation?: LLMDocumentation;
    evaluate(context: TypedExecutionContext, input: unknown): Promise<TypedResult<T>>;
    validate(input: unknown): ValidationResult;
}
export declare class LambdaExpression implements BaseTypedExpression<Function> {
    readonly name = "lambda";
    readonly category: ExpressionCategory;
    readonly syntax = "\\(params) -> expression";
    readonly outputType: EvaluationType;
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly metadata: ExpressionMetadata;
    readonly analysisInfo: {
        isPure: boolean;
        canThrow: boolean;
        complexity: "O(1)";
        dependencies: string[];
    };
    validate(input: unknown): ValidationResult;
    evaluate(context: TypedExecutionContext, input: unknown): Promise<TypedResult<Function>>;
    private evaluateLambdaBody;
}
export declare class PromiseExpression implements BaseTypedExpression<Promise<unknown>> {
    readonly name = "promise";
    readonly category: ExpressionCategory;
    readonly syntax = "promise(executor)";
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    validate(input: unknown): ValidationResult;
    evaluate(_context: TypedExecutionContext, executor: string): Promise<TypedResult<Promise<unknown>>>;
    private parseValue;
}
export declare class AwaitExpression implements BaseTypedExpression<unknown> {
    readonly name = "await";
    readonly category: ExpressionCategory;
    readonly syntax = "await promise";
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    validate(input: unknown): ValidationResult;
    evaluate(_context: TypedExecutionContext, promise: unknown): Promise<TypedResult<unknown>>;
}
export declare class ErrorExpression implements BaseTypedExpression<Error> {
    readonly name = "error";
    readonly category: ExpressionCategory;
    readonly syntax = "error(message, name?, code?)";
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    validate(input: unknown): ValidationResult;
    evaluate(_context: TypedExecutionContext, message: string, name?: string, code?: string): Promise<TypedResult<Error>>;
}
export declare class TypeofExpression implements BaseTypedExpression<string> {
    readonly name = "typeof";
    readonly category: ExpressionCategory;
    readonly syntax = "typeof value";
    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<unknown>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    validate(input: unknown): ValidationResult;
    evaluate(_context: TypedExecutionContext, value: unknown): Promise<TypedResult<string>>;
}
export declare const enhancedAdvancedExpressions: {
    readonly lambda: LambdaExpression;
    readonly promise: PromiseExpression;
    readonly await: AwaitExpression;
    readonly error: ErrorExpression;
    readonly typeof: TypeofExpression;
};
export declare function createLambdaExpression(): LambdaExpression;
export declare function createPromiseExpression(): PromiseExpression;
export declare function createAwaitExpression(): AwaitExpression;
export declare function createErrorExpression(): ErrorExpression;
export declare function createTypeofExpression(): TypeofExpression;
export declare function createLambda(parameters: string[], body: string, context: TypedExecutionContext): Promise<TypedResult<Function>>;
export declare function createPromise(executor: string, context: TypedExecutionContext): Promise<TypedResult<Promise<unknown>>>;
export declare function awaitPromise(promise: unknown, context: TypedExecutionContext): Promise<TypedResult<unknown>>;
export declare function createError(message: string, context: TypedExecutionContext, name?: string, code?: string): Promise<TypedResult<Error>>;
export declare function getTypeOf(value: unknown, context: TypedExecutionContext): Promise<TypedResult<string>>;
export default enhancedAdvancedExpressions;
//# sourceMappingURL=index.d.ts.map