import LiteralToken from "../LiteralToken";
import Token from "../Token";
import TokenType from "../TokenType";
import AssignmentNode from "./AssignmentNode";
import ASTNode from "./ASTNode";
import ASTVisitor from "./ASTVisitor";
export declare abstract class Expression extends ASTNode {
}
/**
 * Represents an unary expression (!right, -right)
 * @category AST
 */
export declare class UnaryOpExpr extends Expression {
    tokens: {
        operator: Token;
    };
    /**
     * The operation of this unary expression.
     */
    operation: TokenType;
    /**
     * The expression on which the operation is performed.
     */
    right: Expression;
    constructor(op: TokenType, right: Expression, tokens: {
        operator: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * Represents a binary expression (LogicalAnd, LogicalOr, Multiply, Divide, Modulo, Plus, Minus, Less, LessEqual, Greater, GreaterEqual, Equal, NotEqual).
 * @category AST
 */
export declare class BinaryOpExpr extends Expression {
    tokens: {
        operator: Token;
    };
    /**
     * The left side of the operation.
     */
    left: Expression;
    /**
     * The type of the operation performed.
     */
    operation: TokenType;
    /**
     * The right side of the operation
     */
    right: Expression;
    constructor(left: Expression, operation: TokenType, right: Expression, tokens: {
        operator: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * Represents a ternary expression (cond ? ifexpr : elsexpr)
 * @category AST
 */
export declare class TernaryExpr extends Expression {
    tokens: {
        questionMark: Token;
        colon: Token;
    };
    cond: Expression;
    ifExpr: Expression;
    elseExpr: Expression;
    constructor(cond: Expression, ifExpr: Expression, elseExpr: Expression, tokens: {
        questionMark: Token;
        colon: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * Represents a lookup operation on an array (indexing). Example: arr[5]
 * @category AST
 */
export declare class ArrayLookupExpr extends Expression {
    tokens: {
        firstBracket: Token;
        secondBracket: Token;
    };
    /**
     * The array being indexed.
     */
    array: Expression;
    /**
     * The index which is being looked up.
     */
    index: Expression;
    constructor(array: Expression, index: Expression, tokens: {
        firstBracket: Token;
        secondBracket: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A literal expression (just a simple number, string or a boolean)
 * @category AST
 */
export declare class LiteralExpr<TValue> extends Expression {
    tokens: {
        literalToken: LiteralToken<TValue>;
    };
    value: TValue;
    constructor(value: TValue, tokens: {
        literalToken: LiteralToken<TValue>;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A range epxression. Example: [0: 1 :20]
 * @category AST
 */
export declare class RangeExpr extends Expression {
    tokens: {
        firstBracket: Token;
        firstColon: Token;
        secondColon: Token | null;
        secondBracket: Token;
    };
    begin: Expression;
    /**
     * The optional step expression.
     * It defaults to 1 if not specified.
     */
    step: Expression | null;
    end: Expression;
    constructor(begin: Expression, step: Expression | null, end: Expression, tokens: {
        firstBracket: Token;
        firstColon: Token;
        secondColon: Token | null;
        secondBracket: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A vector literal expression. Example: [1, 2, 3, 4]
 * @category AST
 */
export declare class VectorExpr extends Expression {
    tokens: {
        firstBracket: Token;
        commas: Token[];
        secondBracket: Token;
    };
    children: Expression[];
    constructor(children: Expression[], tokens: {
        firstBracket: Token;
        commas: Token[];
        secondBracket: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A lookup expression, it references a variable, module or function by name.
 * @category AST
 */
export declare class LookupExpr extends Expression {
    tokens: {
        identifier: Token;
    };
    name: string;
    constructor(name: string, tokens: {
        identifier: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A member lookup expression, (abc.ddd)
 * @category AST
 */
export declare class MemberLookupExpr extends Expression {
    tokens: {
        dot: Token;
        memberName: LiteralToken<string>;
    };
    expr: Expression;
    member: string;
    constructor(expr: Expression, member: string, tokens: {
        dot: Token;
        memberName: LiteralToken<string>;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A function call expression. Example: sin(10)
 * @category AST
 */
export declare class FunctionCallExpr extends Expression {
    tokens: {
        firstParen: Token;
        secondParen: Token;
    };
    /**
     * The expression that is being called.
     */
    callee: Expression;
    /**
     * The named arguments of the function call
     */
    args: AssignmentNode[];
    constructor(callee: Expression, args: AssignmentNode[], tokens: {
        firstParen: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * A common class for the Echo, Assert and Let expression so that the constructor is not copied.
 * @category AST
 */
export declare abstract class FunctionCallLikeExpr extends Expression {
    tokens: {
        name: Token;
        firstParen: Token;
        secondParen: Token;
    };
    /**
     * The names of the assigned variables in this let expression.
     */
    args: AssignmentNode[];
    /**
     * The inner expression which will use the expression.
     */
    expr: Expression;
    constructor(args: AssignmentNode[], expr: Expression, tokens: {
        name: Token;
        firstParen: Token;
        secondParen: Token;
    });
}
/**
 * Represents a let expression. Please note that this is syntactically diffrent from the let module instantation and the let list comprehension.
 * @category AST
 */
export declare class LetExpr extends FunctionCallLikeExpr {
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class AssertExpr extends FunctionCallLikeExpr {
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class EchoExpr extends FunctionCallLikeExpr {
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare abstract class ListComprehensionExpression extends Expression {
}
/**
 * @category AST
 */
export declare class LcIfExpr extends ListComprehensionExpression {
    tokens: {
        ifKeyword: Token;
        firstParen: Token;
        secondParen: Token;
        elseKeyword: Token | null;
    };
    cond: Expression;
    ifExpr: Expression;
    elseExpr: Expression | null;
    constructor(cond: Expression, ifExpr: Expression, elseExpr: Expression | null, tokens: {
        ifKeyword: Token;
        firstParen: Token;
        secondParen: Token;
        elseKeyword: Token | null;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class LcEachExpr extends ListComprehensionExpression {
    tokens: {
        eachKeyword: Token;
    };
    /**
     * The expression where the declared variables will be accessible.
     */
    expr: Expression;
    constructor(expr: Expression, tokens: {
        eachKeyword: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class LcForExpr extends ListComprehensionExpression {
    tokens: {
        forKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    };
    /**
     * The variable names in the for expression
     */
    args: AssignmentNode[];
    /**
     * The expression which will be looped.
     */
    expr: Expression;
    constructor(args: AssignmentNode[], expr: Expression, tokens: {
        forKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class LcForCExpr extends ListComprehensionExpression {
    tokens: {
        forKeyword: Token;
        firstParen: Token;
        firstSemicolon: Token;
        secondSemicolon: Token;
        secondParen: Token;
    };
    /**
     * The variable names in the for expression
     */
    args: AssignmentNode[];
    incrArgs: AssignmentNode[];
    cond: Expression;
    /**
     * The expression which will be looped.
     */
    expr: Expression;
    constructor(args: AssignmentNode[], incrArgs: AssignmentNode[], cond: Expression, expr: Expression, tokens: {
        forKeyword: Token;
        firstParen: Token;
        firstSemicolon: Token;
        secondSemicolon: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * @category AST
 */
export declare class LcLetExpr extends ListComprehensionExpression {
    tokens: {
        letKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    };
    /**
     * The variable names in the let expression
     */
    args: AssignmentNode[];
    /**
     * The expression where the declared variables will be accessible.
     */
    expr: Expression;
    constructor(args: AssignmentNode[], expr: Expression, tokens: {
        letKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * An expression enclosed in parenthesis.
 * @category AST
 */
export declare class GroupingExpr extends Expression {
    tokens: {
        firstParen: Token;
        secondParen: Token;
    };
    inner: Expression;
    constructor(inner: Expression, tokens: {
        firstParen: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}
/**
 * AnonymousFunctionExpr represents a function expression. 'function(x) x * x'
 * @category AST
 */
export declare class AnonymousFunctionExpr extends Expression {
    definitionArgs: AssignmentNode[];
    expr: Expression;
    tokens: {
        functionKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    };
    constructor(definitionArgs: AssignmentNode[], expr: Expression, tokens: {
        functionKeyword: Token;
        firstParen: Token;
        secondParen: Token;
    });
    accept<R>(visitor: ASTVisitor<R>): R;
}