/**
 * AeThex Compiler - Parser (AST Builder)
 * Converts tokens into Abstract Syntax Tree
 */
import { Token } from './Lexer';
export interface ASTNode {
    type: string;
    line: number;
}
export interface Program extends ASTNode {
    type: 'Program';
    body: (Reality | Journey | Import)[];
}
export interface Reality extends ASTNode {
    type: 'Reality';
    name: string;
    properties: Record<string, any>;
}
export interface Journey extends ASTNode {
    type: 'Journey';
    name: string;
    params: string[];
    body: Statement[];
}
export interface Import extends ASTNode {
    type: 'Import';
    specifiers: string[];
    source: string;
}
export type Statement = LetStatement | WhenStatement | NotifyStatement | RevealStatement | SyncStatement | ReturnStatement | ExpressionStatement;
export interface LetStatement extends ASTNode {
    type: 'LetStatement';
    identifier: string;
    value: Expression;
}
export interface WhenStatement extends ASTNode {
    type: 'WhenStatement';
    condition: Expression;
    consequent: Statement[];
    alternate?: Statement[];
}
export interface NotifyStatement extends ASTNode {
    type: 'NotifyStatement';
    message: Expression;
}
export interface RevealStatement extends ASTNode {
    type: 'RevealStatement';
    value: Expression;
}
export interface SyncStatement extends ASTNode {
    type: 'SyncStatement';
    target: Expression;
    platforms: string[];
}
export interface ReturnStatement extends ASTNode {
    type: 'ReturnStatement';
}
export interface ExpressionStatement extends ASTNode {
    type: 'ExpressionStatement';
    expression: Expression;
}
export type Expression = BinaryExpression | UnaryExpression | CallExpression | MemberExpression | Identifier | Literal | ArrayExpression | ObjectExpression | NewExpression;
export interface BinaryExpression extends ASTNode {
    type: 'BinaryExpression';
    operator: string;
    left: Expression;
    right: Expression;
}
export interface UnaryExpression extends ASTNode {
    type: 'UnaryExpression';
    operator: string;
    operand: Expression;
}
export interface CallExpression extends ASTNode {
    type: 'CallExpression';
    callee: Expression;
    arguments: Expression[];
}
export interface MemberExpression extends ASTNode {
    type: 'MemberExpression';
    object: Expression;
    property: Identifier;
}
export interface Identifier extends ASTNode {
    type: 'Identifier';
    name: string;
}
export interface Literal extends ASTNode {
    type: 'Literal';
    value: string | number;
    raw: string;
}
export interface ArrayExpression extends ASTNode {
    type: 'ArrayExpression';
    elements: Expression[];
}
export interface ObjectExpression extends ASTNode {
    type: 'ObjectExpression';
    properties: {
        key: string;
        value: Expression;
    }[];
}
export interface NewExpression extends ASTNode {
    type: 'NewExpression';
    callee: Identifier;
    arguments: Expression[];
}
export declare class Parser {
    private tokens;
    private current;
    constructor(tokens: Token[]);
    parse(): Program;
    private parseTopLevel;
    private parseReality;
    private parseJourney;
    private parseImport;
    private parseStatement;
    private parseLetStatement;
    private parseWhenStatement;
    private parseNotifyStatement;
    private parseRevealStatement;
    private parseSyncStatement;
    private parseReturnStatement;
    private parseExpression;
    private parseComparison;
    private parseAdditive;
    private parseMultiplicative;
    private parseUnary;
    private parsePostfix;
    private parsePrimary;
    private parseArrayExpression;
    private parseObjectExpression;
    private parseNewExpression;
    private parseArray;
    private check;
    private advance;
    private isAtEnd;
    private peek;
    private previous;
    private consume;
}
//# sourceMappingURL=Parser.d.ts.map