mathjslab/lib/types/MathJSLabParser.d.ts

MathJSLab - An interpreter with language syntax like MATLAB®/Octave, ISBN 978-65-00-82338-7.

import { ATN, DFA, FailedPredicateException, Parser, RuleContext, ParserRuleContext, TerminalNode, Token, TokenStream } from 'antlr4';
import type { ExpressionBoundaryValue, NodeInput, NodeIdentifier, NodeEndRange, NodeMetaClass, NodeColon, NodeIgnoredTarget, NodeOperation, NodeIndexExpr, NodeSuperclassConstructor, NodeIndirectRef, NodeRange, NodeFunctionDefinition, NodeFunctionParameter, NodeFunctionReturn, NodeDeclarationElement, NodeList, NodeArgumentValidation, NodeArguments, NodeImport, NodeIf, NodeElseIf, NodeElse, NodeSwitch, NodeSwitchCase, NodeWhile, NodeDoUntil, NodeFor, NodeSpmd, NodeTry, NodeUnwindProtect, NodeClassDef, NodeClassSection, NodeClassProperty, NodeClassEvent, NodeClassEnumeration, NodeClassAttribute } from './AST';
import type { ComplexType } from './Complex';
import type { FunctionHandle } from './FunctionHandle';
import type { MultiArray } from './MultiArray';
import type { CharString } from './CharString';
type ParserConstantNode = ComplexType | CharString | NodeEndRange;
type ParserPrimaryExpressionNode = NodeIdentifier | ParserConstantNode | FunctionHandle | NodeMetaClass | MultiArray<ExpressionBoundaryValue> | NodeOperation | NodeImport;
type ParserOperatorExpressionNode = ParserPrimaryExpressionNode | NodeOperation | NodeIndexExpr | NodeSuperclassConstructor | NodeIndirectRef;
type ParserSimpleExpressionNode = ParserOperatorExpressionNode | NodeRange;
type ParserExpressionNode = ParserSimpleExpressionNode | FunctionHandle | NodeOperation;
type ParserAssignmentTargetNode = ParserSimpleExpressionNode | MultiArray<ExpressionBoundaryValue>;
type ParserArgumentValidationNameNode = NodeIdentifier | NodeIndirectRef;
/**
 * # MathJSLabParser
 *
 * A parser that recognizes a language syntax like MATLAB®/Octave written in TypeScript.
 *
 * ## References
 * - [MATLAB Operator Precedence](https://www.mathworks.com/help/matlab/matlab_prog/operator-precedence.html)
 * - [Octave lexer](https://github.com/gnu-octave/octave/blob/default/libinterp/parse-tree/lex.ll)
 * - [Octave parser](https://github.com/gnu-octave/octave/blob/default/libinterp/parse-tree/oct-parse.yy)
 * - [An ANTLR4 grammar for MATLAB files.](https://github.com/antlr/grammars-v4/tree/master/matlab)
 * - [mparser](https://www.mathworks.com/matlabcentral/fileexchange/32769-mparser)
 */
export default class MathJSLabParser extends Parser {
    static readonly GLOBAL = 1;
    static readonly PERSISTENT = 2;
    static readonly IMPORT = 3;
    static readonly IF = 4;
    static readonly ENDIF = 5;
    static readonly END = 6;
    static readonly ENDRANGE = 7;
    static readonly ELSEIF = 8;
    static readonly ELSE = 9;
    static readonly SWITCH = 10;
    static readonly ENDSWITCH = 11;
    static readonly CASE = 12;
    static readonly OTHERWISE = 13;
    static readonly WHILE = 14;
    static readonly ENDWHILE = 15;
    static readonly DO = 16;
    static readonly UNTIL = 17;
    static readonly FOR = 18;
    static readonly ENDFOR = 19;
    static readonly PARFOR = 20;
    static readonly ENDPARFOR = 21;
    static readonly SPMD = 22;
    static readonly ENDSPMD = 23;
    static readonly BREAK = 24;
    static readonly CONTINUE = 25;
    static readonly RETURN = 26;
    static readonly FUNCTION = 27;
    static readonly ENDFUNCTION = 28;
    static readonly TRY = 29;
    static readonly CATCH = 30;
    static readonly END_TRY_CATCH = 31;
    static readonly UNWIND_PROTECT = 32;
    static readonly UNWIND_PROTECT_CLEANUP = 33;
    static readonly END_UNWIND_PROTECT = 34;
    static readonly CLASSDEF = 35;
    static readonly ENDCLASSDEF = 36;
    static readonly ENUMERATION = 37;
    static readonly ENDENUMERATION = 38;
    static readonly PROPERTIES = 39;
    static readonly ENDPROPERTIES = 40;
    static readonly EVENTS = 41;
    static readonly ENDEVENTS = 42;
    static readonly METHODS = 43;
    static readonly ENDMETHODS = 44;
    static readonly WSPACE = 45;
    static readonly STRING = 46;
    static readonly ARGUMENTS = 47;
    static readonly ENDARGUMENTS = 48;
    static readonly PLUS = 49;
    static readonly MINUS = 50;
    static readonly MUL = 51;
    static readonly DIV = 52;
    static readonly EQ = 53;
    static readonly COLON = 54;
    static readonly SEMICOLON = 55;
    static readonly COMMA = 56;
    static readonly DOT = 57;
    static readonly TILDE = 58;
    static readonly EXCLAMATION = 59;
    static readonly COMMAT = 60;
    static readonly QUESTION = 61;
    static readonly LPAREN = 62;
    static readonly RPAREN = 63;
    static readonly LBRACKET = 64;
    static readonly RBRACKET = 65;
    static readonly LCURLYBR = 66;
    static readonly RCURLYBR = 67;
    static readonly LEFTDIV = 68;
    static readonly ADD_EQ = 69;
    static readonly SUB_EQ = 70;
    static readonly MUL_EQ = 71;
    static readonly DIV_EQ = 72;
    static readonly LEFTDIV_EQ = 73;
    static readonly POW_EQ = 74;
    static readonly EMUL_EQ = 75;
    static readonly EDIV_EQ = 76;
    static readonly ELEFTDIV_EQ = 77;
    static readonly EPOW_EQ = 78;
    static readonly AND_EQ = 79;
    static readonly OR_EQ = 80;
    static readonly EXPR_AND_AND = 81;
    static readonly EXPR_OR_OR = 82;
    static readonly EXPR_AND = 83;
    static readonly EXPR_OR = 84;
    static readonly EXPR_LT = 85;
    static readonly EXPR_LE = 86;
    static readonly EXPR_EQ = 87;
    static readonly EXPR_NE = 88;
    static readonly EXPR_GE = 89;
    static readonly EXPR_GT = 90;
    static readonly EMUL = 91;
    static readonly EDIV = 92;
    static readonly ELEFTDIV = 93;
    static readonly PLUS_PLUS = 94;
    static readonly MINUS_MINUS = 95;
    static readonly POW = 96;
    static readonly EPOW = 97;
    static readonly TRANSPOSE = 98;
    static readonly HERMITIAN = 99;
    static readonly DQSTRING = 100;
    static readonly IDENTIFIER = 101;
    static readonly FLOAT_NUMBER = 102;
    static readonly NUMBER_DOT_OP = 103;
    static readonly LINE_CONTINUATION = 104;
    static readonly SPACE_OR_CONTINUATION = 105;
    static readonly NEWLINE = 106;
    static readonly BLOCK_COMMENT_START = 107;
    static readonly COMMENT_LINE = 108;
    static readonly INVALID = 109;
    static readonly SINGLEQ_STRING = 110;
    static readonly SINGLEQ_NL = 111;
    static readonly SINGLEQ_SINGLEQ = 112;
    static readonly SINGLEQ_END = 113;
    static readonly DOUBLEQ_STRING = 114;
    static readonly DOUBLEQ_NL = 115;
    static readonly DOUBLEQ_DOUBLEQ = 116;
    static readonly DOUBLEQ_ESCAPE = 117;
    static readonly DOUBLEQ_ESCAPE_OTHER = 118;
    static readonly DOUBLEQ_ESCAPE_OCT = 119;
    static readonly DOUBLEQ_ESCAPE_HEX = 120;
    static readonly DOUBLEQ_ESCAPE_UNICODE = 121;
    static readonly DOUBLEQ_END = 122;
    static readonly BLOCK_COMMENT_START_AGAIN = 123;
    static readonly BLOCK_COMMENT_END = 124;
    static readonly BLOCK_COMMENT_LINE = 125;
    static readonly BLOCK_COMMENT_EOF = 126;
    static readonly COMMAND_LINE_CONTINUATION = 127;
    static readonly COMMAND_CONTINUED_BLOCK_COMMENT_START = 128;
    static readonly COMMAND_CONTINUED_COMMENT_LINE = 129;
    static readonly COMMAND_CONTINUED_NEWLINE = 130;
    static readonly SKIP_SPACE = 131;
    static readonly COMMAND_LONE_DQUOTE = 132;
    static readonly COMMAND_LONE_SQUOTE = 133;
    static readonly COMMAND_UNCLOSED_DQUOTE = 134;
    static readonly COMMAND_UNCLOSED_SQUOTE = 135;
    static readonly COMMAND_DQSTRING = 136;
    static readonly COMMAND_SQSTRING = 137;
    static readonly SKIP_COMMENT_LINE = 138;
    static readonly COMMAND_SEPARATOR = 139;
    static readonly EXIT_AT_NEWLINE = 140;
    static readonly EXIT_AT_EOF = 141;
    static readonly UNQUOTED_STRING = 142;
    static readonly EOF: number;
    static readonly RULE_input = 0;
    static readonly RULE_global_list = 1;
    static readonly RULE_list = 2;
    static readonly RULE_statement = 3;
    static readonly RULE_word_list_cmd = 4;
    static readonly RULE_command_word = 5;
    static readonly RULE_identifier = 6;
    static readonly RULE_qualified_identifier_part = 7;
    static readonly RULE_qualified_identifier = 8;
    static readonly RULE_string = 9;
    static readonly RULE_number = 10;
    static readonly RULE_end_range = 11;
    static readonly RULE_constant = 12;
    static readonly RULE_matrix = 13;
    static readonly RULE_matrix_row = 14;
    static readonly RULE_fcn_handle = 15;
    static readonly RULE_meta_class = 16;
    static readonly RULE_anon_fcn_handle = 17;
    static readonly RULE_primary_expr = 18;
    static readonly RULE_magic_colon = 19;
    static readonly RULE_magic_tilde = 20;
    static readonly RULE_list_element = 21;
    static readonly RULE_arg_list = 22;
    static readonly RULE_oper_expr = 23;
    static readonly RULE_power_expr = 24;
    static readonly RULE_colon_expr = 25;
    static readonly RULE_simple_expr = 26;
    static readonly RULE_expression = 27;
    static readonly RULE_assign_lhs = 28;
    static readonly RULE_assign_list = 29;
    static readonly RULE_command = 30;
    static readonly RULE_declaration = 31;
    static readonly RULE_declaration_element = 32;
    static readonly RULE_import_command = 33;
    static readonly RULE_import_name = 34;
    static readonly RULE_select_command = 35;
    static readonly RULE_if_command = 36;
    static readonly RULE_elseif_clause = 37;
    static readonly RULE_else_clause = 38;
    static readonly RULE_switch_command = 39;
    static readonly RULE_switch_case_list = 40;
    static readonly RULE_switch_case = 41;
    static readonly RULE_otherwise_case = 42;
    static readonly RULE_loop_command = 43;
    static readonly RULE_while_command = 44;
    static readonly RULE_do_until_command = 45;
    static readonly RULE_for_command = 46;
    static readonly RULE_spmd_command = 47;
    static readonly RULE_spmd_worker_spec = 48;
    static readonly RULE_jump_command = 49;
    static readonly RULE_except_command = 50;
    static readonly RULE_try_command = 51;
    static readonly RULE_catch_clause = 52;
    static readonly RULE_unwind_command = 53;
    static readonly RULE_unwind_cleanup_clause = 54;
    static readonly RULE_param_list = 55;
    static readonly RULE_param_list_elt = 56;
    static readonly RULE_return_list_elt = 57;
    static readonly RULE_return_list = 58;
    static readonly RULE_function = 59;
    static readonly RULE_function_name = 60;
    static readonly RULE_classdef_command = 61;
    static readonly RULE_class_attribute_list = 62;
    static readonly RULE_class_attribute = 63;
    static readonly RULE_class_method_name = 64;
    static readonly RULE_class_superclass_list = 65;
    static readonly RULE_class_section_list = 66;
    static readonly RULE_class_section = 67;
    static readonly RULE_properties_section = 68;
    static readonly RULE_class_property_list = 69;
    static readonly RULE_class_property = 70;
    static readonly RULE_methods_section = 71;
    static readonly RULE_class_method = 72;
    static readonly RULE_class_method_list = 73;
    static readonly RULE_events_section = 74;
    static readonly RULE_class_event_list = 75;
    static readonly RULE_class_event = 76;
    static readonly RULE_enumeration_section = 77;
    static readonly RULE_class_enumeration_list = 78;
    static readonly RULE_class_enumeration = 79;
    static readonly RULE_arguments_block_list = 80;
    static readonly RULE_arguments_block = 81;
    static readonly RULE_arguments_attribute_list = 82;
    static readonly RULE_args_validation_list = 83;
    static readonly RULE_arg_validation = 84;
    static readonly RULE_arg_validation_name = 85;
    static readonly RULE_sep_no_nl = 86;
    static readonly RULE_nl = 87;
    static readonly RULE_sep = 88;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    input(): InputContext;
    global_list(): Global_listContext;
    list(): ListContext;
    statement(): StatementContext;
    word_list_cmd(): Word_list_cmdContext;
    command_word(): Command_wordContext;
    identifier(): IdentifierContext;
    qualified_identifier_part(): Qualified_identifier_partContext;
    qualified_identifier(): Qualified_identifierContext;
    string_(): StringContext;
    number_(): NumberContext;
    end_range(): End_rangeContext;
    constant(): ConstantContext;
    matrix(): MatrixContext;
    matrix_row(): Matrix_rowContext;
    fcn_handle(): Fcn_handleContext;
    meta_class(): Meta_classContext;
    anon_fcn_handle(): Anon_fcn_handleContext;
    primary_expr(): Primary_exprContext;
    magic_colon(): Magic_colonContext;
    magic_tilde(): Magic_tildeContext;
    list_element(): List_elementContext;
    arg_list(): Arg_listContext;
    oper_expr(): Oper_exprContext;
    oper_expr(_p: number): Oper_exprContext;
    power_expr(): Power_exprContext;
    power_expr(_p: number): Power_exprContext;
    colon_expr(): Colon_exprContext;
    simple_expr(): Simple_exprContext;
    simple_expr(_p: number): Simple_exprContext;
    expression(): ExpressionContext;
    assign_lhs(): Assign_lhsContext;
    assign_list(): Assign_listContext;
    command(): CommandContext;
    declaration(): DeclarationContext;
    declaration_element(): Declaration_elementContext;
    import_command(): Import_commandContext;
    import_name(): Import_nameContext;
    select_command(): Select_commandContext;
    if_command(): If_commandContext;
    elseif_clause(): Elseif_clauseContext;
    else_clause(): Else_clauseContext;
    switch_command(): Switch_commandContext;
    switch_case_list(): Switch_case_listContext;
    switch_case(): Switch_caseContext;
    otherwise_case(): Otherwise_caseContext;
    loop_command(): Loop_commandContext;
    while_command(): While_commandContext;
    do_until_command(): Do_until_commandContext;
    for_command(): For_commandContext;
    spmd_command(): Spmd_commandContext;
    spmd_worker_spec(): Spmd_worker_specContext;
    jump_command(): Jump_commandContext;
    except_command(): Except_commandContext;
    try_command(): Try_commandContext;
    catch_clause(): Catch_clauseContext;
    unwind_command(): Unwind_commandContext;
    unwind_cleanup_clause(): Unwind_cleanup_clauseContext;
    param_list(): Param_listContext;
    param_list_elt(): Param_list_eltContext;
    return_list_elt(): Return_list_eltContext;
    return_list(): Return_listContext;
    function_(): FunctionContext;
    function_name(): Function_nameContext;
    classdef_command(): Classdef_commandContext;
    class_attribute_list(): Class_attribute_listContext;
    class_attribute(): Class_attributeContext;
    class_method_name(): Class_method_nameContext;
    class_superclass_list(): Class_superclass_listContext;
    class_section_list(): Class_section_listContext;
    class_section(): Class_sectionContext;
    properties_section(): Properties_sectionContext;
    class_property_list(): Class_property_listContext;
    class_property(): Class_propertyContext;
    methods_section(): Methods_sectionContext;
    class_method(): Class_methodContext;
    class_method_list(): Class_method_listContext;
    events_section(): Events_sectionContext;
    class_event_list(): Class_event_listContext;
    class_event(): Class_eventContext;
    enumeration_section(): Enumeration_sectionContext;
    class_enumeration_list(): Class_enumeration_listContext;
    class_enumeration(): Class_enumerationContext;
    arguments_block_list(): Arguments_block_listContext;
    arguments_block(): Arguments_blockContext;
    arguments_attribute_list(): Arguments_attribute_listContext;
    args_validation_list(): Args_validation_listContext;
    arg_validation(): Arg_validationContext;
    arg_validation_name(): Arg_validation_nameContext;
    sep_no_nl(): Sep_no_nlContext;
    nl(): NlContext;
    sep(): SepContext;
    sempred(localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private oper_expr_sempred;
    private power_expr_sempred;
    private simple_expr_sempred;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): ATN;
    static DecisionsToDFA: DFA[];
}
export declare class InputContext extends ParserRuleContext {
    node: NodeInput | null;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    EOF(): TerminalNode;
    sep(): SepContext;
    global_list(): Global_listContext;
    get ruleIndex(): number;
}
export declare class Global_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class ListContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class StatementContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    command(): CommandContext;
    word_list_cmd(): Word_list_cmdContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Word_list_cmdContext extends ParserRuleContext {
    node: NodeInput;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    command_word_list(): Command_wordContext[];
    command_word(i: number): Command_wordContext;
    get ruleIndex(): number;
}
export declare class Command_wordContext extends ParserRuleContext {
    node: CharString;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    string_(): StringContext;
    get ruleIndex(): number;
}
export declare class IdentifierContext extends ParserRuleContext {
    node: NodeIdentifier;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    IDENTIFIER(): TerminalNode;
    PROPERTIES(): TerminalNode;
    METHODS(): TerminalNode;
    EVENTS(): TerminalNode;
    ENUMERATION(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Qualified_identifier_partContext extends ParserRuleContext {
    text: string;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    END(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Qualified_identifierContext extends ParserRuleContext {
    node: NodeIdentifier;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    qualified_identifier_part_list(): Qualified_identifier_partContext[];
    qualified_identifier_part(i: number): Qualified_identifier_partContext;
    DOT_list(): TerminalNode[];
    DOT(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class StringContext extends ParserRuleContext {
    node: CharString;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    STRING(): TerminalNode;
    UNQUOTED_STRING(): TerminalNode;
    get ruleIndex(): number;
}
export declare class NumberContext extends ParserRuleContext {
    node: ComplexType;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    FLOAT_NUMBER(): TerminalNode;
    get ruleIndex(): number;
}
export declare class End_rangeContext extends ParserRuleContext {
    node: NodeEndRange;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ENDRANGE(): TerminalNode;
    get ruleIndex(): number;
}
export declare class ConstantContext extends ParserRuleContext {
    node: ParserConstantNode;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    number_(): NumberContext;
    string_(): StringContext;
    end_range(): End_rangeContext;
    get ruleIndex(): number;
}
export declare class MatrixContext extends ParserRuleContext {
    node: MultiArray<ExpressionBoundaryValue>;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    nl_list(): NlContext[];
    nl(i: number): NlContext;
    matrix_row_list(): Matrix_rowContext[];
    matrix_row(i: number): Matrix_rowContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Matrix_rowContext extends ParserRuleContext {
    node: NodeList | null;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    WSPACE_list(): TerminalNode[];
    WSPACE(i: number): TerminalNode;
    list_element_list(): List_elementContext[];
    list_element(i: number): List_elementContext;
    get ruleIndex(): number;
}
export declare class Fcn_handleContext extends ParserRuleContext {
    node: FunctionHandle;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMAT(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    get ruleIndex(): number;
}
export declare class Meta_classContext extends ParserRuleContext {
    node: NodeMetaClass;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    QUESTION(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    get ruleIndex(): number;
}
export declare class Anon_fcn_handleContext extends ParserRuleContext {
    node: FunctionHandle;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMAT(): TerminalNode;
    param_list(): Param_listContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Primary_exprContext extends ParserRuleContext {
    node: ParserPrimaryExpressionNode;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    IMPORT(): TerminalNode;
    constant(): ConstantContext;
    fcn_handle(): Fcn_handleContext;
    meta_class(): Meta_classContext;
    matrix(): MatrixContext;
    LPAREN(): TerminalNode;
    expression(): ExpressionContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Magic_colonContext extends ParserRuleContext {
    node: NodeColon;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Magic_tildeContext extends ParserRuleContext {
    node: NodeIgnoredTarget;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    TILDE(): TerminalNode;
    get ruleIndex(): number;
}
export declare class List_elementContext extends ParserRuleContext {
    node: ParserExpressionNode | NodeColon | NodeIgnoredTarget;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    magic_colon(): Magic_colonContext;
    magic_tilde(): Magic_tildeContext;
    get ruleIndex(): number;
}
export declare class Arg_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    list_element_list(): List_elementContext[];
    list_element(i: number): List_elementContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Oper_exprContext extends ParserRuleContext {
    node: ParserOperatorExpressionNode;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    primary_expr(): Primary_exprContext;
    oper_expr_list(): Oper_exprContext[];
    oper_expr(i: number): Oper_exprContext;
    PLUS_PLUS(): TerminalNode;
    MINUS_MINUS(): TerminalNode;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    TILDE(): TerminalNode;
    EXCLAMATION(): TerminalNode;
    MUL(): TerminalNode;
    DIV(): TerminalNode;
    LEFTDIV(): TerminalNode;
    EMUL(): TerminalNode;
    EDIV(): TerminalNode;
    ELEFTDIV(): TerminalNode;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    arg_list(): Arg_listContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    COMMAT(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    TRANSPOSE(): TerminalNode;
    HERMITIAN(): TerminalNode;
    DOT(): TerminalNode;
    qualified_identifier_part(): Qualified_identifier_partContext;
    expression(): ExpressionContext;
    power_expr(): Power_exprContext;
    POW(): TerminalNode;
    EPOW(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Power_exprContext extends ParserRuleContext {
    node: ParserOperatorExpressionNode;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    primary_expr(): Primary_exprContext;
    power_expr(): Power_exprContext;
    PLUS_PLUS(): TerminalNode;
    MINUS_MINUS(): TerminalNode;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    TILDE(): TerminalNode;
    EXCLAMATION(): TerminalNode;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    arg_list(): Arg_listContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    COMMAT(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    DOT(): TerminalNode;
    qualified_identifier_part(): Qualified_identifier_partContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Colon_exprContext extends ParserRuleContext {
    node: NodeRange;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    oper_expr_list(): Oper_exprContext[];
    oper_expr(i: number): Oper_exprContext;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Simple_exprContext extends ParserRuleContext {
    node: ParserSimpleExpressionNode;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    oper_expr(): Oper_exprContext;
    colon_expr(): Colon_exprContext;
    simple_expr_list(): Simple_exprContext[];
    simple_expr(i: number): Simple_exprContext;
    EXPR_LT(): TerminalNode;
    EXPR_LE(): TerminalNode;
    EXPR_GT(): TerminalNode;
    EXPR_GE(): TerminalNode;
    EXPR_EQ(): TerminalNode;
    EXPR_NE(): TerminalNode;
    EXPR_AND(): TerminalNode;
    EXPR_OR(): TerminalNode;
    EXPR_AND_AND(): TerminalNode;
    EXPR_OR_OR(): TerminalNode;
    get ruleIndex(): number;
}
export declare class ExpressionContext extends ParserRuleContext {
    node: ParserExpressionNode;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    simple_expr(): Simple_exprContext;
    expression(): ExpressionContext;
    EQ(): TerminalNode;
    ADD_EQ(): TerminalNode;
    SUB_EQ(): TerminalNode;
    MUL_EQ(): TerminalNode;
    EMUL_EQ(): TerminalNode;
    DIV_EQ(): TerminalNode;
    EDIV_EQ(): TerminalNode;
    LEFTDIV_EQ(): TerminalNode;
    ELEFTDIV_EQ(): TerminalNode;
    POW_EQ(): TerminalNode;
    EPOW_EQ(): TerminalNode;
    AND_EQ(): TerminalNode;
    OR_EQ(): TerminalNode;
    anon_fcn_handle(): Anon_fcn_handleContext;
    get ruleIndex(): number;
}
export declare class Assign_lhsContext extends ParserRuleContext {
    node: ParserAssignmentTargetNode;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    simple_expr(): Simple_exprContext;
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    assign_list(): Assign_listContext;
    get ruleIndex(): number;
}
export declare class Assign_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    list_element_list(): List_elementContext[];
    list_element(i: number): List_elementContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    WSPACE_list(): TerminalNode[];
    WSPACE(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class CommandContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    declaration(): DeclarationContext;
    import_command(): Import_commandContext;
    select_command(): Select_commandContext;
    loop_command(): Loop_commandContext;
    jump_command(): Jump_commandContext;
    except_command(): Except_commandContext;
    function_(): FunctionContext;
    classdef_command(): Classdef_commandContext;
    get ruleIndex(): number;
}
export declare class DeclarationContext extends ParserRuleContext {
    node: NodeInput;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    declaration_element_list(): Declaration_elementContext[];
    declaration_element(i: number): Declaration_elementContext;
    GLOBAL(): TerminalNode;
    PERSISTENT(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Declaration_elementContext extends ParserRuleContext {
    node: NodeDeclarationElement;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Import_commandContext extends ParserRuleContext {
    node: NodeImport;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    IMPORT(): TerminalNode;
    import_name_list(): Import_nameContext[];
    import_name(i: number): Import_nameContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Import_nameContext extends ParserRuleContext {
    node: NodeIdentifier;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    qualified_identifier(): Qualified_identifierContext;
    DOT(): TerminalNode;
    MUL(): TerminalNode;
    EMUL(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Select_commandContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    if_command(): If_commandContext;
    switch_command(): Switch_commandContext;
    get ruleIndex(): number;
}
export declare class If_commandContext extends ParserRuleContext {
    node: NodeIf;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    IF(): TerminalNode;
    expression(): ExpressionContext;
    END(): TerminalNode;
    ENDIF(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    elseif_clause_list(): Elseif_clauseContext[];
    elseif_clause(i: number): Elseif_clauseContext;
    else_clause(): Else_clauseContext;
    get ruleIndex(): number;
}
export declare class Elseif_clauseContext extends ParserRuleContext {
    node: NodeElseIf;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ELSEIF(): TerminalNode;
    expression(): ExpressionContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Else_clauseContext extends ParserRuleContext {
    node: NodeElse;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ELSE(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Switch_commandContext extends ParserRuleContext {
    node: NodeSwitch;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    SWITCH(): TerminalNode;
    expression(): ExpressionContext;
    END(): TerminalNode;
    ENDSWITCH(): TerminalNode;
    sep(): SepContext;
    switch_case_list(): Switch_case_listContext;
    otherwise_case(): Otherwise_caseContext;
    get ruleIndex(): number;
}
export declare class Switch_case_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    switch_case_list(): Switch_caseContext[];
    switch_case(i: number): Switch_caseContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Switch_caseContext extends ParserRuleContext {
    node: NodeSwitchCase;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    CASE(): TerminalNode;
    expression(): ExpressionContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Otherwise_caseContext extends ParserRuleContext {
    node: NodeList;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    OTHERWISE(): TerminalNode;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Loop_commandContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    while_command(): While_commandContext;
    do_until_command(): Do_until_commandContext;
    for_command(): For_commandContext;
    spmd_command(): Spmd_commandContext;
    get ruleIndex(): number;
}
export declare class While_commandContext extends ParserRuleContext {
    node: NodeWhile;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    WHILE(): TerminalNode;
    expression(): ExpressionContext;
    END(): TerminalNode;
    ENDWHILE(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Do_until_commandContext extends ParserRuleContext {
    node: NodeDoUntil;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    DO(): TerminalNode;
    UNTIL(): TerminalNode;
    expression(): ExpressionContext;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class For_commandContext extends ParserRuleContext {
    node: NodeFor;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    assign_lhs(): Assign_lhsContext;
    EQ(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    END(): TerminalNode;
    ENDFOR(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    PARFOR(): TerminalNode;
    ENDPARFOR(): TerminalNode;
    COMMA(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Spmd_commandContext extends ParserRuleContext {
    node: NodeSpmd;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    SPMD(): TerminalNode;
    END(): TerminalNode;
    ENDSPMD(): TerminalNode;
    spmd_worker_spec(): Spmd_worker_specContext;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Spmd_worker_specContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    RPAREN(): TerminalNode;
    COMMA(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Jump_commandContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    BREAK(): TerminalNode;
    CONTINUE(): TerminalNode;
    RETURN(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Except_commandContext extends ParserRuleContext {
    node: NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    try_command(): Try_commandContext;
    unwind_command(): Unwind_commandContext;
    get ruleIndex(): number;
}
export declare class Try_commandContext extends ParserRuleContext {
    node: NodeTry;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    TRY(): TerminalNode;
    catch_clause(): Catch_clauseContext;
    END(): TerminalNode;
    END_TRY_CATCH(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Catch_clauseContext extends ParserRuleContext {
    body: NodeList;
    identifierNode: NodeIdentifier | null;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    CATCH(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Unwind_commandContext extends ParserRuleContext {
    node: NodeUnwindProtect;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    UNWIND_PROTECT(): TerminalNode;
    unwind_cleanup_clause(): Unwind_cleanup_clauseContext;
    END(): TerminalNode;
    END_UNWIND_PROTECT(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Unwind_cleanup_clauseContext extends ParserRuleContext {
    node: NodeList;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    UNWIND_PROTECT_CLEANUP(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Param_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    param_list_elt_list(): Param_list_eltContext[];
    param_list_elt(i: number): Param_list_eltContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Param_list_eltContext extends ParserRuleContext {
    node: NodeFunctionParameter;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    declaration_element(): Declaration_elementContext;
    magic_tilde(): Magic_tildeContext;
    get ruleIndex(): number;
}
export declare class Return_list_eltContext extends ParserRuleContext {
    node: NodeFunctionReturn;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    magic_tilde(): Magic_tildeContext;
    get ruleIndex(): number;
}
export declare class Return_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    return_list_elt_list(): Return_list_eltContext[];
    return_list_elt(i: number): Return_list_eltContext;
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    WSPACE_list(): TerminalNode[];
    WSPACE(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class FunctionContext extends ParserRuleContext {
    node: NodeFunctionDefinition;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    function_name(): Function_nameContext;
    END(): TerminalNode;
    ENDFUNCTION(): TerminalNode;
    EOF(): TerminalNode;
    return_list(): Return_listContext;
    EQ(): TerminalNode;
    param_list(): Param_listContext;
    sep(): SepContext;
    arguments_block_list(): Arguments_block_listContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Function_nameContext extends ParserRuleContext {
    node: NodeIdentifier;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    qualified_identifier(): Qualified_identifierContext;
    get ruleIndex(): number;
}
export declare class Classdef_commandContext extends ParserRuleContext {
    node: NodeClassDef;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    CLASSDEF(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    END(): TerminalNode;
    ENDCLASSDEF(): TerminalNode;
    EOF(): TerminalNode;
    class_attribute_list(): Class_attribute_listContext;
    class_superclass_list(): Class_superclass_listContext;
    sep(): SepContext;
    class_section_list(): Class_section_listContext;
    get ruleIndex(): number;
}
export declare class Class_attribute_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    class_attribute_list(): Class_attributeContext[];
    class_attribute(i: number): Class_attributeContext;
    sep(): SepContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Class_attributeContext extends ParserRuleContext {
    node: NodeClassAttribute;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    TILDE(): TerminalNode;
    EXCLAMATION(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Class_method_nameContext extends ParserRuleContext {
    node: NodeIdentifier;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOT_list(): TerminalNode[];
    DOT(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Class_superclass_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    EXPR_LT(): TerminalNode;
    qualified_identifier_list(): Qualified_identifierContext[];
    qualified_identifier(i: number): Qualified_identifierContext;
    EXPR_AND_list(): TerminalNode[];
    EXPR_AND(i: number): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Class_section_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    class_section_list(): Class_sectionContext[];
    class_section(i: number): Class_sectionContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Class_sectionContext extends ParserRuleContext {
    node: NodeClassSection;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    properties_section(): Properties_sectionContext;
    methods_section(): Methods_sectionContext;
    events_section(): Events_sectionContext;
    enumeration_section(): Enumeration_sectionContext;
    get ruleIndex(): number;
}
export declare class Properties_sectionContext extends ParserRuleContext {
    node: NodeClassSection;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    PROPERTIES(): TerminalNode;
    END(): TerminalNode;
    ENDPROPERTIES(): TerminalNode;
    class_attribute_list(): Class_attribute_listContext;
    sep(): SepContext;
    class_property_list(): Class_property_listContext;
    get ruleIndex(): number;
}
export declare class Class_property_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    class_property_list(): Class_propertyContext[];
    class_property(i: number): Class_propertyContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Class_propertyContext extends ParserRuleContext {
    node: NodeClassProperty;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    LPAREN(): TerminalNode;
    arg_list_list(): Arg_listContext[];
    arg_list(i: number): Arg_listContext;
    RPAREN(): TerminalNode;
    qualified_identifier(): Qualified_identifierContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Methods_sectionContext extends ParserRuleContext {
    node: NodeClassSection;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    METHODS(): TerminalNode;
    END(): TerminalNode;
    ENDMETHODS(): TerminalNode;
    class_attribute_list(): Class_attribute_listContext;
    sep(): SepContext;
    class_method_list(): Class_method_listContext;
    get ruleIndex(): number;
}
export declare class Class_methodContext extends ParserRuleContext {
    node: NodeFunctionDefinition;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    function_(): FunctionContext;
    class_method_name(): Class_method_nameContext;
    param_list(): Param_listContext;
    return_list(): Return_listContext;
    EQ(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Class_method_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    class_method_list(): Class_methodContext[];
    class_method(i: number): Class_methodContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Events_sectionContext extends ParserRuleContext {
    node: NodeClassSection;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    EVENTS(): TerminalNode;
    END(): TerminalNode;
    ENDEVENTS(): TerminalNode;
    class_attribute_list(): Class_attribute_listContext;
    sep(): SepContext;
    class_event_list(): Class_event_listContext;
    get ruleIndex(): number;
}
export declare class Class_event_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    class_event_list(): Class_eventContext[];
    class_event(i: number): Class_eventContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Class_eventContext extends ParserRuleContext {
    node: NodeClassEvent;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    get ruleIndex(): number;
}
export declare class Enumeration_sectionContext extends ParserRuleContext {
    node: NodeClassSection;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ENUMERATION(): TerminalNode;
    END(): TerminalNode;
    ENDENUMERATION(): TerminalNode;
    class_attribute_list(): Class_attribute_listContext;
    sep(): SepContext;
    class_enumeration_list(): Class_enumeration_listContext;
    get ruleIndex(): number;
}
export declare class Class_enumeration_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    class_enumeration_list(): Class_enumerationContext[];
    class_enumeration(i: number): Class_enumerationContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Class_enumerationContext extends ParserRuleContext {
    node: NodeClassEnumeration;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    arg_list(): Arg_listContext;
    get ruleIndex(): number;
}
export declare class Arguments_block_listContext extends ParserRuleContext {
    node: NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    arguments_block_