import { TokenType } from '../../index';
export interface Program {
    statements: Array<Statement>;
    errors: Array<ParseError>;
}
export declare enum Priority {
    LOWEST = 1,
    ASSIGN = 2,
    AND_OR = 3,
    EQUAL = 4,
    LESS_GREATER = 5,
    SUM = 6,
    PRODUCT = 7,
    PREFIX = 8,
    CALL = 9,
    INDEX = 10
}
export declare type Statement = LetStatement | ReturnStatement | ExpressionStatement | BlockStatement | WhileStatement | DecoratorStatement;
export declare type Expression = LiteralExpression | BlockStatement | PrefixExpression | InfixExpression | IfExpression | MatchExpression | FunctionExpression | CallExpression | IdentExpression | ArrayExpression | IndexExpression | ObjectExpression | TypeofExpression | ThrowExpression | DeleteExpression | UseExpression | VoidExpression | ExprExpression | null;
export declare enum ExpressionKind {
    Literal = 0,
    Block = 1,
    Prefix = 2,
    Infix = 3,
    If = 4,
    Match = 5,
    Function = 6,
    Call = 7,
    Ident = 8,
    Array = 9,
    Index = 10,
    Object = 11,
    Typeof = 12,
    Throw = 13,
    Delete = 14,
    Use = 15,
    Void = 16,
    Expr = 17,
    Null = 18
}
export declare enum NodeKind {
    Program = 100,
    LetStatement = 101,
    ReturnStatement = 102,
    ExpressionStatement = 103,
    WhileStatement = 104,
    DecoratorStatement = 105
}
export declare enum LiteralKind {
    String = 200,
    Number = 201,
    Boolean = 202,
    Null = 203
}
export interface Debug {
    debug?: string;
}
export interface Position {
    line: number;
    column: number;
}
export interface LetStatement extends Debug, Position {
    ident: Expression;
    value: Expression;
    kind: NodeKind.LetStatement;
}
export interface ReturnStatement extends Debug, Position {
    value: Expression;
    kind: NodeKind.ReturnStatement;
}
export interface WhileStatement extends Debug, Position {
    condition: Expression;
    body: Expression;
    kind: NodeKind.WhileStatement;
}
export interface DecoratorStatement extends Debug, Position {
    value: Expression;
    function: Expression;
    kind: NodeKind.DecoratorStatement;
}
export interface ExpressionStatement extends Debug, Position {
    expression: Expression;
    kind: NodeKind.ExpressionStatement;
}
export interface LiteralExpression extends Debug, Position {
    value: NumberLiteral | StringLiteral | BooleanLiteral | NullLiteral;
    kind: ExpressionKind.Literal;
}
export interface BlockStatement extends Debug, Position {
    statements: Array<Statement>;
    returnFinal: boolean;
    kind: ExpressionKind.Block;
}
export interface PrefixExpression extends Debug, Position {
    operator: TokenType;
    right: Expression;
    kind: ExpressionKind.Prefix;
}
export interface InfixExpression extends Debug, Position {
    left: Expression;
    right: Expression;
    operator: TokenType;
    kind: ExpressionKind.Infix;
}
export interface IfExpression extends Debug, Position {
    condition: Expression;
    consequence: Expression;
    alternative: Expression | null;
    kind: ExpressionKind.If;
}
export interface MatchExpression extends Debug, Position {
    condition: Expression;
    cases: Array<MatchCase>;
    kind: ExpressionKind.Match;
}
export interface MatchCase extends Debug, Position {
    pattern: Expression;
    body: Expression;
}
export interface FunctionExpression extends Debug, Position {
    function: Expression;
    parameters: Array<Expression>;
    body: Expression;
    kind: ExpressionKind.Function;
}
export interface CallExpression extends Debug, Position {
    function: Expression;
    parameters: Array<Expression>;
    kind: ExpressionKind.Call;
}
export interface ArrayExpression extends Debug, Position {
    elements: Array<Expression>;
    kind: ExpressionKind.Array;
}
export interface IndexExpression extends Debug, Position {
    left: Expression;
    index: Expression;
    kind: ExpressionKind.Index;
}
export interface IdentExpression extends Debug, Position {
    value: string;
    kind: ExpressionKind.Ident;
}
export interface ObjectExpression extends Debug, Position {
    pairs: Array<ObjectPair>;
    kind: ExpressionKind.Object;
}
export interface ObjectPair extends Debug, Position {
    key: Expression;
    value: Expression;
}
export interface TypeofExpression extends Debug, Position {
    value: Expression;
    kind: ExpressionKind.Typeof;
}
export interface ThrowExpression extends Debug, Position {
    message: Expression;
    line: number;
    column: number;
    kind: ExpressionKind.Throw;
}
export interface DeleteExpression extends Debug, Position {
    value: Expression;
    kind: ExpressionKind.Delete;
}
export interface UseExpression extends Debug, Position {
    path: Expression;
    kind: ExpressionKind.Use;
}
export interface VoidExpression extends Debug, Position {
    value: Expression;
    kind: ExpressionKind.Void;
}
export interface ExprExpression extends Debug, Position {
    value: Expression;
    kind: ExpressionKind.Expr;
}
export interface NumberLiteral extends Debug, Position {
    value: number;
    kind: LiteralKind.Number;
}
export interface StringLiteral extends Debug, Position {
    value: string;
    kind: LiteralKind.String;
}
export interface BooleanLiteral extends Debug, Position {
    value: boolean;
    kind: LiteralKind.Boolean;
}
export interface NullLiteral extends Debug, Position {
    kind: LiteralKind.Null;
}
export interface ParseError extends Position {
    message: string;
}