import { FormatExpression } from "../../parser.js";
import { ApplySymbolExpression } from "../apply-symbol-expression.js";
import { BinaryExpression } from "../binary-expression.js";
import { CallExpression } from "../call-expression.js";
import { ConstantExpression } from "../constant-expression.js";
import type { Expressions, StrictExpressions } from "../expression.js";
import { TypedLambdaExpression } from "../lambda-expression.js";
import { MemberExpression } from "../member-expression.js";
import { NewExpression } from "../new-expression.js";
import { ParameterExpression } from "../parameter-expression.js";
import { TernaryExpression } from "../ternary-expression.js";
import { UnaryExpression } from "../unary-expression.js";
import { ExpressionVisitor } from "./expression-visitor.js";
/**
 * Compares two expressions.
 * @param {any} expr1 - The first expression.
 * @param {any} expr2 - The second expression.
 * @returns {boolean} True if the expressions are equal, false otherwise.
 */
export declare class ExpressionComparer extends ExpressionVisitor {
    private source;
    constructor(source: Expressions);
    static equals(exp1: Expressions, exp2: Expressions): boolean;
    visitMember<T, TMember extends keyof T>(arg0: MemberExpression<T, TMember, T[TMember]>): StrictExpressions;
    visitApplySymbol<T, U>(arg0: ApplySymbolExpression<T, U>): StrictExpressions;
    visitBinary<T extends Expressions = StrictExpressions>(expression: BinaryExpression<T>): BinaryExpression<Expressions>;
    visitCall<T, TMethod extends keyof T>(arg0: CallExpression<T, TMethod>): StrictExpressions;
    visitConstant(arg0: ConstantExpression<unknown>): StrictExpressions;
    visitFormat<TOutput>(expression: FormatExpression<TOutput>): FormatExpression<TOutput>;
    visitLambda<T extends (...args: unknown[]) => unknown>(arg0: TypedLambdaExpression<T>): StrictExpressions;
    visitNew<T>(arg0: NewExpression<T>): StrictExpressions;
    visitParameter(arg0: ParameterExpression<unknown>): StrictExpressions;
    visitTernary<T extends Expressions = StrictExpressions>(arg0: TernaryExpression<T>): TernaryExpression<Expressions>;
    visitUnary(arg0: UnaryExpression): Expressions;
}