import type { ASTNode } from "./ast";
import { type Token } from "./lexer";
/**
 * Parser error class
 */
export declare class ParseError extends Error {
    position?: {
        start: number;
        end: number;
    } | undefined;
    constructor(message: string, position?: {
        start: number;
        end: number;
    } | undefined);
}
/**
 * Formula parser class
 */
export declare class Parser {
    private tokens;
    private input;
    constructor(tokens: Token[], input?: string);
    /**
     * Look ahead to determine if this is a workbook reference like
     * [Workbook]!Table[...] or [Workbook]Sheet...
     */
    private lookAheadForWorkbookReference;
    /**
     * Parse workbook reference like [Workbook]!Table[Column] or [Workbook]Sheet!A1
     */
    private parseWorkbookReference;
    private parseWorkbookQualifiedTableReference;
    /**
     * Parse bare column reference like [Column] or [Column1:Column2]
     */
    private parseBareColumnReference;
    /**
     * Parse a column name that might consist of multiple identifiers separated by spaces, contain dashes, or have parentheses
     */
    private parseColumnName;
    /**
     * Parse a formula string
     */
    static parse(formula: string): ASTNode;
    /**
     * Parse the entire formula
     */
    parseFormula(): ASTNode;
    /**
     * Parse an expression (entry point for recursive descent)
     */
    private parseExpression;
    /**
     * Parse binary expressions using precedence climbing
     */
    private parseBinaryExpression;
    /**
     * Parse unary expressions
     */
    private parseUnaryExpression;
    /**
     * Parse postfix expressions (currently just %)
     */
    private parsePostfixExpression;
    /**
     * Parse primary expressions
     */
    private parsePrimaryExpression;
    /**
     * Parse an absolute reference starting with $
     */
    private parseAbsoluteReference;
    /**
     * Parse a number literal or row range
     */
    private parseNumber;
    /**
     * Parse a string literal
     */
    private parseString;
    /**
     * Parse a boolean literal
     */
    private parseBoolean;
    /**
     * Parse an error literal
     */
    private parseError;
    /**
     * Parse a function call
     */
    private parseFunctionCall;
    /**
     * Parse an identifier (cell reference, range, or named expression)
     */
    private parseIdentifier;
    /**
     * Check if a string is a valid column identifier (A-Z, AA-ZZ, etc.)
     */
    private isColumnIdentifier;
    /**
     * Parse the end part of a range (handling $ signs, infinite ranges, and open-ended ranges)
     */
    private parseRangeEnd;
    /**
     * Parse a parenthesized expression
     */
    private parseParenthesizedExpression;
    /**
     * Parse an array literal
     */
    private parseArrayLiteral;
    /**
     * Parse a cell reference string
     */
    private parseCellReferenceString;
    /**
     * Parse table reference (e.g., Table1[Column1])
     */
    private parseTableReference;
    /**
     * Parse table reference with sheet name (e.g., Sheet1!Table1[Column1])
     */
    private parseTableReferenceWithSheet;
    /**
     * Parse cell or range after sheet range in 3D reference
     */
    private parseCellOrRangeAfterSheets;
    /**
     * Parse current row reference (e.g., [@Column], [@[Column Name]], or just @Column)
     */
    private parseCurrentRowReference;
    /**
     * Parse table selector (e.g., #Headers, #Data)
     */
    private parseTableSelector;
    /**
     * Parse a range reference with workbook name
     */
    private parseRangeWithWorkbook;
    /**
     * Parse a range reference (including infinite ranges)
     */
    private parseRange;
    /**
     * Parse a cell or range reference with a known workbook and sheet name
     */
    private parseCellOrRangeWithWorkbookAndSheet;
    /**
     * Parse a cell or range reference with a known sheet name
     */
    private parseCellOrRangeWithSheet;
}
/**
 * Parse a formula string into an AST
 */
export declare function parseFormula(formula: string): ASTNode;