import { t as Token, A as ASTNode, I as ISymbolType, a as Config, w as ReferenceRecord } from './types-C15dTNyD.js';

declare class Lexer {
    private text;
    private currentChar;
    private pos;
    private line;
    private column;
    constructor(text: string);
    private error;
    private advance;
    private eat;
    private peek;
    private skipWhitespace;
    private skipLine;
    private isComment;
    private number;
    private isDigit;
    private isValidIdentifierStart;
    private isValidStringElement;
    private stringElement;
    private reference;
    private explicitString;
    private hexColor;
    nextToken(): Token;
    peekToken(): Token | null;
    peekTokens(n: number): Token[] | null;
    isEOF(): boolean;
    getSourceInfo(): {
        text: string;
        pos: number;
        line: number;
        column: number;
    };
}

declare class Parser {
    private lexer;
    private currentToken;
    requiredReferences: Set<string>;
    constructor(lexer: Lexer);
    private formatError;
    private peekTokens;
    private error;
    private eat;
    private typeDeclaration;
    private statementsList;
    private statement;
    private assignVariable;
    private reassignVariable;
    private reference;
    private expr;
    private conditionExpr;
    private returnStatement;
    private whileStatement;
    private ifStatement;
    private block;
    private implicitListExpr;
    private listExpr;
    private logicTerm;
    private comparison;
    private term;
    private power;
    private format;
    private number;
    private factor;
    private attributeAccess;
    private functionCall;
    parse(inlineMode?: boolean): ASTNode | null;
}
interface ParseExpressionResult {
    lexer: Lexer;
    parser: Parser;
    ast: ASTNode | null;
}
declare function parseExpression(text: string): ParseExpressionResult;

declare class SymbolTable {
    private symbols;
    constructor();
    get(name: string): ISymbolType | null;
    set(name: string, value: ISymbolType | null): void;
    isDefined(name: string): boolean;
    reset(): void;
}

type InterpreterResult = ISymbolType | string | null;
declare class Interpreter {
    private parser;
    private symbolTable;
    private references;
    private ast;
    config: Config;
    constructor(input: Parser | ASTNode | null, options?: {
        references?: ReferenceRecord | Map<string, any>;
        symbolTable?: SymbolTable;
        config?: Config;
    });
    importReferences(references?: ReferenceRecord | Map<string, any>): void;
    getReference(key: string): ISymbolType | undefined;
    setAst(ast: ASTNode | null): void;
    resetSymbolTable(): void;
    coerceValue(constructorSymbol: ISymbolType, valueSymbol: ISymbolType): ISymbolType | undefined;
    private visit;
    private visitBinOpNode;
    private visitNumNode;
    private visitStringNode;
    /**
     * Bare identifiers are treated as string literals if not found as variables
     * Check symbol table first (variables override references), then references
     */
    private visitIdentifierNode;
    private visitUnaryOpNode;
    private visitListNode;
    private visitImplicitListNode;
    private visitReferenceNode;
    private visitHexColorNode;
    private visitBooleanNode;
    private visitNullNode;
    private visitElementWithUnitNode;
    private visitFunctionCallNode;
    private visitAssignNode;
    private visitReassignNode;
    private visitAttributeAccessNode;
    private visitStatementListNode;
    private visitReturnNode;
    private visitWhileNode;
    private visitIfNode;
    interpret(): InterpreterResult;
}

export { Interpreter as I, Lexer as L, Parser as P, type InterpreterResult as a, parseExpression as p };
