import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
/**
 * Utility class to traverse and remove ParameterExpression nodes from the SQL AST.
 * This removes any binary expression containing a ParameterExpression as a whole.
 * For compound logical expressions (AND/OR), only the parameterized parts are removed.
 * If all conditions are removed from a logical expression, the parent node is removed as well.
 */
export declare class ParameterRemover implements SqlComponentVisitor<SqlComponent | null> {
    private handlers;
    private visitedNodes;
    private isRootVisit;
    constructor();
    /**
     * Reset the visited nodes tracking
     */
    private reset;
    /**
     * Main entry point for the visitor pattern.
     * @param arg The SQL component to visit
     * @returns The component with parameter expressions removed, or null if the entire component should be removed
     */
    visit(arg: SqlComponent): SqlComponent | null;
    /**
     * Internal visit method used for all nodes.
     * This separates the visit flag management from the actual node visitation logic.
     */
    private visitNode;
    /**
     * Visit SimpleSelectQuery node
     */
    private visitSimpleSelectQuery;
    /**
     * Visit BinarySelectQuery node
     */
    private visitBinarySelectQuery;
    /**
     * Visit ValuesQuery node
     */
    private visitValuesQuery;
    /**
     * Visit WithClause node
     */
    private visitWithClause;
    /**
     * Visit CommonTable node
     */
    private visitCommonTable;
    /**
     * Visit SelectClause node
     */
    private visitSelectClause;
    /**
     * Visit SelectItem node
     */
    private visitSelectItem;
    private visitIdentifierString;
    private visitRawString;
    private visitColumnReference;
    private visitParameterExpression;
    private visitLiteralValue;
    private visitTableSource;
    private visitForClause;
    private visitDistinctComponent;
    /**
     * Visit SourceExpression node
     */
    private visitSourceExpression;
    /**
     * Visit ParenSource node
     */
    private visitParenSource;
    /**
     * Visit SourceAliasExpression node
     */
    private visitSourceAliasExpression;
    /**
     * Visit SubQuerySource node
     */
    private visitSubQuerySource;
    /**
     * Visit InlineQuery node
     */
    private visitInlineQuery;
    /**
     * Visit FromClause node
     */
    private visitFromClause;
    /**
     * Visit JoinClause node
     */
    private visitJoinClause;
    /**
     * Visit JoinOnClause node
     */
    private visitJoinOnClause;
    /**
     * Visit JoinUsingClause node
     */
    private visitJoinUsingClause;
    /**
     * Visit WhereClause node - key method for parameter removal
     */
    private visitWhereClause;
    /**
     * Visit ParenExpression node
     */
    private visitParenExpression;
    /**
     * Visit BinaryExpression node - improved logic for right-associative parser structure
     */
    private visitBinaryExpression;
    /**
     * Handle comparison expressions, accounting for right-associative parser structure
     */
    private handleComparisonExpression;
    /**
     * Restructure expressions like "id = (1 AND ...)" to "(id = 1) AND ..."
     */
    private restructureComparisonWithLogical;
    /**
     * Check if an operator is a logical operator     */
    /**
     * Check if the resulting expression would be nonsensical
     * This is a heuristic to detect cases like "name = age > 18"
     */
    private wouldCreateNonsensicalExpression;
    /**
     * Check if a ValueComponent contains a ParameterExpression anywhere in its tree
     */
    private containsParameter;
    /**
     * Visit UnaryExpression node
     */
    private visitUnaryExpression;
    /**
     * Visit CaseExpression node
     */
    private visitCaseExpression;
    /**
     * Visit CaseKeyValuePair node
     */
    private visitCaseKeyValuePair;
    /**
     * Visit SwitchCaseArgument node
     */
    private visitSwitchCaseArgument;
    /**
     * Visit BetweenExpression node
    */
    private visitBetweenExpression;
    /**
     * Visit FunctionCall node
     */
    private visitFunctionCall;
    /**
     * Visit ArrayExpression node
     */
    private visitArrayExpression;
    /**
     * Visit TupleExpression node
     */
    private visitTupleExpression;
    /**
     * Visit CastExpression node
     */
    private visitCastExpression;
    /**
     * Visit WindowFrameExpression node
     */
    private visitWindowFrameExpression;
    /**
     * Visit WindowFrameSpec node
     */
    private visitWindowFrameSpec;
    /**
     * Visit TypeValue node
     */
    private visitTypeValue;
    /**
     * Visit GroupByClause node
     */
    private visitGroupByClause;
    /**
     * Visit HavingClause node
     */
    private visitHavingClause;
    /**
     * Visit OrderByClause node
     */
    private visitOrderByClause;
    /**
     * Visit OrderByItem node
     */
    private visitOrderByItem;
    /**
     * Visit WindowFrameClause node
     */
    private visitWindowFrameClause;
    /**
     * Visit WindowsClause node
     */
    private visitWindowsClause;
    /**
     * Visit LimitClause node
     */
    private visitLimitClause;
    /**
     * Visit OffsetClause node
     */
    private visitOffsetClause;
    /**
     * Visit FetchClause node
     */
    private visitFetchClause;
    /**
     * Visit FetchExpression node
     */
    private visitFetchExpression;
    /**
     * Static method to apply parameter removal transformation on an SQL AST
     * @param node The SQL AST node to transform
     * @returns The transformed SQL AST with parameter expressions removed
     */
    static remove(node: SqlComponent): SqlComponent | null;
}