import { Expression, type Expressions, type TypedExpression } from './expression.js';
import { ExpressionType } from './expression-type.js';
import { ParameterExpression } from './parameter-expression.js';
import type { ExpressionVisitor } from './visitors/expression-visitor.js';
/**
 * Represents a typed lambda expression.
 * @template T - The type of the lambda function.
 */
export declare class TypedLambdaExpression<T extends (...args: unknown[]) => unknown> extends Expression {
    readonly body: Expressions;
    /** @override */
    get type(): ExpressionType.LambdaExpression;
    /** All parameters defined for this lambda expression */
    readonly parameters: Parameters<T>;
    /**
     * Initialize a new typed lambda expression instance
     * @param {Expressions} body - Expression representing the lambda's execution logic
     * @param {Parameters<T>} parameters - List of parameter definitions for this lambda
     */
    constructor(body: Expressions, ...parameters: Parameters<T>);
    /**
     * Accepts an expression visitor as part of the visitor pattern
     * @param visitor - Visitor instance implementing the lambda visitation logic
     */
    accept(visitor: ExpressionVisitor): import("./expression.js").StrictExpressions;
}
/**
 * Infers parameter types from a function type and creates corresponding ParameterExpression instances.
 * @template T - The function type from which parameters are inferred.
 */
export type Parameters<T> = T extends (a: infer T1) => unknown ? [ParameterExpression<T1>] : T extends (a: infer T1, b: infer T2) => unknown ? [ParameterExpression<T1>, ParameterExpression<T2>] : T extends (a: infer T1, b: infer T2, c: infer T3) => unknown ? [ParameterExpression<T1>, ParameterExpression<T2>, ParameterExpression<T3>] : T extends (a: infer T1, b: infer T2, c: infer T3, d: infer T4) => unknown ? [ParameterExpression<T1>, ParameterExpression<T2>, ParameterExpression<T3>, ParameterExpression<T4>] : T extends (a: infer T1, b: infer T2, c: infer T3, d: infer T4, e: infer T5) => unknown ? [ParameterExpression<T1>, ParameterExpression<T2>, ParameterExpression<T3>, ParameterExpression<T4>, ParameterExpression<T5>] : T extends (a: infer T1, b: infer T2, c: infer T3, d: infer T4, e: infer T5, f: infer T6) => unknown ? [
    T1 extends never | void ? void : ParameterExpression<T1>,
    T2 extends never | void ? void : ParameterExpression<T2>,
    T3 extends never | void ? void : ParameterExpression<T3>,
    T4 extends never | void ? void : ParameterExpression<T4>,
    T5 extends never | void ? void : ParameterExpression<T5>,
    T6 extends never | void ? void : ParameterExpression<T6>
] : T extends (...args: unknown[]) => unknown ? ParameterExpression<unknown>[] : never;
/**
 * Represents a lambda expression.
 */
export declare class LambdaExpression extends TypedLambdaExpression<(...args: unknown[]) => unknown> {
    readonly body: Expressions;
    /**
     * Creates a strongly-typed lambda expression instance.
     * @template T - The function type representing the lambda's signature.
     * @template U - The return type of the lambda function.
     * @param {TypedExpression<U>} body - The expression representing the lambda's body.
     * @param {Parameters<T>} parameters - Array of parameter expressions matching the function's signature.
     * @returns {TypedLambdaExpression<T>} A new typed lambda expression instance.
     */
    static typed<T extends (...args: unknown[]) => U, U>(body: TypedExpression<U>, parameters: Parameters<T>): TypedLambdaExpression<T>;
    /**
     * Creates a new LambdaExpression instance.
     * @param {Expressions} body - The expression tree representing the lambda's execution logic.
     * @param {...Parameters<(...args: unknown[]) => unknown>} parameters - List of parameter expressions defining the lambda's input.
     */
    constructor(body: Expressions, ...parameters: Parameters<(...args: unknown[]) => unknown>);
}