openpinescript 0.0.0-stage → 0.1.1

package/dist/types/parser/v6/generated/PineV6Parser.d.ts

@@ -0,0 +1,984 @@
+import * as antlr from "antlr4ng";
+import { PineV6ParserVisitor } from "./PineV6ParserVisitor.js";
+export declare class PineV6Parser extends antlr.Parser {
+    static readonly BEGIN = 1;
+    static readonly END = 2;
+    static readonly LEND = 3;
+    static readonly ONCE = 4;
+    static readonly MLSTRING_DQ = 5;
+    static readonly MLSTRING_SQ = 6;
+    static readonly WHILE = 7;
+    static readonly SWITCH = 8;
+    static readonly TYPE = 9;
+    static readonly METHOD = 10;
+    static readonly IMPORT = 11;
+    static readonly EXPORT = 12;
+    static readonly ENUM = 13;
+    static readonly AS = 14;
+    static readonly IN = 15;
+    static readonly VAR = 16;
+    static readonly VARIP = 17;
+    static readonly SERIES = 18;
+    static readonly SIMPLE = 19;
+    static readonly CONST = 20;
+    static readonly INT_TYPE = 21;
+    static readonly FLOAT_TYPE = 22;
+    static readonly BOOL_TYPE = 23;
+    static readonly STRING_TYPE = 24;
+    static readonly COLOR_TYPE = 25;
+    static readonly LINE_TYPE = 26;
+    static readonly LABEL_TYPE = 27;
+    static readonly BOX_TYPE = 28;
+    static readonly TABLE_TYPE = 29;
+    static readonly PLUS_ASSIGN = 30;
+    static readonly MINUS_ASSIGN = 31;
+    static readonly MUL_ASSIGN = 32;
+    static readonly DIV_ASSIGN = 33;
+    static readonly MOD_ASSIGN = 34;
+    static readonly ASSIGN = 35;
+    static readonly LBEG = 36;
+    static readonly IF_COND = 37;
+    static readonly IF_COND_ELSE = 38;
+    static readonly FOR_STMT = 39;
+    static readonly FOR_STMT_TO = 40;
+    static readonly FOR_STMT_BY = 41;
+    static readonly BREAK = 42;
+    static readonly CONTINUE = 43;
+    static readonly OR = 44;
+    static readonly AND = 45;
+    static readonly NOT = 46;
+    static readonly BOOL_LITERAL = 47;
+    static readonly COND = 48;
+    static readonly COND_ELSE = 49;
+    static readonly EQ = 50;
+    static readonly NEQ = 51;
+    static readonly GT = 52;
+    static readonly GE = 53;
+    static readonly LT = 54;
+    static readonly LE = 55;
+    static readonly PLUS = 56;
+    static readonly MINUS = 57;
+    static readonly MUL = 58;
+    static readonly DIV = 59;
+    static readonly MOD = 60;
+    static readonly DEFINE = 61;
+    static readonly ARROW = 62;
+    static readonly COMMA = 63;
+    static readonly LPAR = 64;
+    static readonly RPAR = 65;
+    static readonly LSQBR = 66;
+    static readonly RSQBR = 67;
+    static readonly INT_LITERAL = 68;
+    static readonly FLOAT_LITERAL = 69;
+    static readonly STR_LITERAL = 70;
+    static readonly COLOR_LITERAL = 71;
+    static readonly ID = 72;
+    static readonly WS = 73;
+    static readonly LINE_COMMENT = 74;
+    static readonly BLOCK_COMMENT = 75;
+    static readonly DOT = 76;
+    static readonly RULE_once_expr = 0;
+    static readonly RULE_other_literal = 1;
+    static readonly RULE_global_stmt_content = 2;
+    static readonly RULE_local_stmt_content = 3;
+    static readonly RULE_id = 4;
+    static readonly RULE_export_stmt = 5;
+    static readonly RULE_while_expr = 6;
+    static readonly RULE_switch_expr = 7;
+    static readonly RULE_switch_body = 8;
+    static readonly RULE_switch_case = 9;
+    static readonly RULE_field_type = 10;
+    static readonly RULE_type_def_stmt = 11;
+    static readonly RULE_type_body = 12;
+    static readonly RULE_type_field = 13;
+    static readonly RULE_method_def_stmt = 14;
+    static readonly RULE_enum_def_stmt = 15;
+    static readonly RULE_enum_body = 16;
+    static readonly RULE_enum_field = 17;
+    static readonly RULE_import_stmt = 18;
+    static readonly RULE_import_path = 19;
+    static readonly RULE_import_user = 20;
+    static readonly RULE_user_part = 21;
+    static readonly RULE_fun_param = 22;
+    static readonly RULE_type_args = 23;
+    static readonly RULE_type_arg = 24;
+    static readonly RULE_for_in_expr = 25;
+    static readonly RULE_call_suffix = 26;
+    static readonly RULE_fun_call = 27;
+    static readonly RULE_atom = 28;
+    static readonly RULE_stmt = 29;
+    static readonly RULE_fun_head = 30;
+    static readonly RULE_var_def = 31;
+    static readonly RULE_var_defs = 32;
+    static readonly RULE_id_part = 33;
+    static readonly RULE_arith_expr = 34;
+    static readonly RULE_decl_mod = 35;
+    static readonly RULE_type_qual = 36;
+    static readonly RULE_type_name = 37;
+    static readonly RULE_compound_assign_op = 38;
+    static readonly RULE_var_assign = 39;
+    static readonly RULE_if_expr = 40;
+    static readonly RULE_pos_arg = 41;
+    static readonly RULE_pos_args = 42;
+    static readonly RULE_pine_script = 43;
+    static readonly RULE_global_stmt = 44;
+    static readonly RULE_fun_def_stmt = 45;
+    static readonly RULE_fun_def_singleline = 46;
+    static readonly RULE_fun_def_multiline = 47;
+    static readonly RULE_fun_body_singleline = 48;
+    static readonly RULE_local_stmt_singleline = 49;
+    static readonly RULE_loop_break = 50;
+    static readonly RULE_loop_continue = 51;
+    static readonly RULE_fun_body_multiline = 52;
+    static readonly RULE_local_stmts_multiline = 53;
+    static readonly RULE_local_stmts_list = 54;
+    static readonly RULE_local_stmt_multiline = 55;
+    static readonly RULE_ids_array = 56;
+    static readonly RULE_arith_exprs = 57;
+    static readonly RULE_for_expr = 58;
+    static readonly RULE_stmts_block = 59;
+    static readonly RULE_ternary_expr = 60;
+    static readonly RULE_or_expr = 61;
+    static readonly RULE_and_expr = 62;
+    static readonly RULE_eq_expr = 63;
+    static readonly RULE_cmp_expr = 64;
+    static readonly RULE_add_expr = 65;
+    static readonly RULE_mult_expr = 66;
+    static readonly RULE_unary_expr = 67;
+    static readonly RULE_sqbr_expr = 68;
+    static readonly RULE_fun_actual_args = 69;
+    static readonly RULE_kw_args = 70;
+    static readonly RULE_kw_arg = 71;
+    static readonly RULE_literal = 72;
+    static readonly RULE_num_literal = 73;
+    static readonly literalNames: string[];
+    static readonly symbolicNames: string[];
+    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): antlr.FailedPredicateException;
+    constructor(input: antlr.TokenStream);
+    once_expr(): Once_exprContext;
+    other_literal(): Other_literalContext;
+    global_stmt_content(): Global_stmt_contentContext;
+    local_stmt_content(): Local_stmt_contentContext;
+    id(): IdContext;
+    export_stmt(): Export_stmtContext;
+    while_expr(): While_exprContext;
+    switch_expr(): Switch_exprContext;
+    switch_body(): Switch_bodyContext;
+    switch_case(): Switch_caseContext;
+    field_type(): Field_typeContext;
+    type_def_stmt(): Type_def_stmtContext;
+    type_body(): Type_bodyContext;
+    type_field(): Type_fieldContext;
+    method_def_stmt(): Method_def_stmtContext;
+    enum_def_stmt(): Enum_def_stmtContext;
+    enum_body(): Enum_bodyContext;
+    enum_field(): Enum_fieldContext;
+    import_stmt(): Import_stmtContext;
+    import_path(): Import_pathContext;
+    import_user(): Import_userContext;
+    user_part(): User_partContext;
+    fun_param(): Fun_paramContext;
+    type_args(): Type_argsContext;
+    type_arg(): Type_argContext;
+    for_in_expr(): For_in_exprContext;
+    call_suffix(): Call_suffixContext;
+    fun_call(): Fun_callContext;
+    atom(): AtomContext;
+    stmt(): StmtContext;
+    fun_head(): Fun_headContext;
+    var_def(): Var_defContext;
+    var_defs(): Var_defsContext;
+    id_part(): Id_partContext;
+    arith_expr(): Arith_exprContext;
+    decl_mod(): Decl_modContext;
+    type_qual(): Type_qualContext;
+    type_name(): Type_nameContext;
+    compound_assign_op(): Compound_assign_opContext;
+    var_assign(): Var_assignContext;
+    if_expr(): If_exprContext;
+    pos_arg(): Pos_argContext;
+    pos_args(): Pos_argsContext;
+    pine_script(): Pine_scriptContext;
+    global_stmt(): Global_stmtContext;
+    fun_def_stmt(): Fun_def_stmtContext;
+    fun_def_singleline(): Fun_def_singlelineContext;
+    fun_def_multiline(): Fun_def_multilineContext;
+    fun_body_singleline(): Fun_body_singlelineContext;
+    local_stmt_singleline(): Local_stmt_singlelineContext;
+    loop_break(): Loop_breakContext;
+    loop_continue(): Loop_continueContext;
+    fun_body_multiline(): Fun_body_multilineContext;
+    local_stmts_multiline(): Local_stmts_multilineContext;
+    local_stmts_list(): Local_stmts_listContext;
+    local_stmt_multiline(): Local_stmt_multilineContext;
+    ids_array(): Ids_arrayContext;
+    arith_exprs(): Arith_exprsContext;
+    for_expr(): For_exprContext;
+    stmts_block(): Stmts_blockContext;
+    ternary_expr(): Ternary_exprContext;
+    or_expr(): Or_exprContext;
+    and_expr(): And_exprContext;
+    eq_expr(): Eq_exprContext;
+    cmp_expr(): Cmp_exprContext;
+    add_expr(): Add_exprContext;
+    mult_expr(): Mult_exprContext;
+    unary_expr(): Unary_exprContext;
+    sqbr_expr(): Sqbr_exprContext;
+    fun_actual_args(): Fun_actual_argsContext;
+    kw_args(): Kw_argsContext;
+    kw_arg(): Kw_argContext;
+    literal(): LiteralContext;
+    num_literal(): Num_literalContext;
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
+}
+export declare class Once_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ONCE(): antlr.TerminalNode;
+    stmts_block(): Stmts_blockContext;
+    ternary_expr(): Ternary_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Other_literalContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    STR_LITERAL(): antlr.TerminalNode | null;
+    BOOL_LITERAL(): antlr.TerminalNode | null;
+    COLOR_LITERAL(): antlr.TerminalNode | null;
+    MLSTRING_DQ(): antlr.TerminalNode | null;
+    MLSTRING_SQ(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Global_stmt_contentContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    var_def(): Var_defContext | null;
+    var_defs(): Var_defsContext | null;
+    fun_call(): Fun_callContext | null;
+    if_expr(): If_exprContext | null;
+    var_assign(): Var_assignContext | null;
+    for_expr(): For_exprContext | null;
+    for_in_expr(): For_in_exprContext | null;
+    while_expr(): While_exprContext | null;
+    switch_expr(): Switch_exprContext | null;
+    once_expr(): Once_exprContext | null;
+    loop_break(): Loop_breakContext | null;
+    loop_continue(): Loop_continueContext | null;
+    arith_expr(): Arith_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Local_stmt_contentContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    var_def(): Var_defContext | null;
+    var_defs(): Var_defsContext | null;
+    arith_expr(): Arith_exprContext | null;
+    arith_exprs(): Arith_exprsContext | null;
+    var_assign(): Var_assignContext | null;
+    while_expr(): While_exprContext | null;
+    once_expr(): Once_exprContext | null;
+    loop_break(): Loop_breakContext | null;
+    loop_continue(): Loop_continueContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class IdContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id_part(): Id_partContext[];
+    id_part(i: number): Id_partContext | null;
+    DOT(): antlr.TerminalNode[];
+    DOT(i: number): antlr.TerminalNode | null;
+    TYPE(): antlr.TerminalNode[];
+    TYPE(i: number): antlr.TerminalNode | null;
+    METHOD(): antlr.TerminalNode[];
+    METHOD(i: number): antlr.TerminalNode | null;
+    IMPORT(): antlr.TerminalNode[];
+    IMPORT(i: number): antlr.TerminalNode | null;
+    EXPORT(): antlr.TerminalNode[];
+    EXPORT(i: number): antlr.TerminalNode | null;
+    ENUM(): antlr.TerminalNode[];
+    ENUM(i: number): antlr.TerminalNode | null;
+    ONCE(): antlr.TerminalNode[];
+    ONCE(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Export_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    EXPORT(): antlr.TerminalNode;
+    type_def_stmt(): Type_def_stmtContext | null;
+    enum_def_stmt(): Enum_def_stmtContext | null;
+    method_def_stmt(): Method_def_stmtContext | null;
+    fun_def_stmt(): Fun_def_stmtContext | null;
+    var_def(): Var_defContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class While_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    WHILE(): antlr.TerminalNode;
+    ternary_expr(): Ternary_exprContext;
+    stmts_block(): Stmts_blockContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Switch_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    SWITCH(): antlr.TerminalNode;
+    switch_body(): Switch_bodyContext;
+    ternary_expr(): Ternary_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Switch_bodyContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BEGIN(): antlr.TerminalNode;
+    END(): antlr.TerminalNode;
+    switch_case(): Switch_caseContext[];
+    switch_case(i: number): Switch_caseContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Switch_caseContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ARROW(): antlr.TerminalNode;
+    local_stmt_singleline(): Local_stmt_singlelineContext | null;
+    stmts_block(): Stmts_blockContext | null;
+    ternary_expr(): Ternary_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Field_typeContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    type_name(): Type_nameContext | null;
+    id(): IdContext | null;
+    type_args(): Type_argsContext | null;
+    LSQBR(): antlr.TerminalNode | null;
+    RSQBR(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_def_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    TYPE(): antlr.TerminalNode;
+    id(): IdContext;
+    type_body(): Type_bodyContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_bodyContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BEGIN(): antlr.TerminalNode;
+    END(): antlr.TerminalNode;
+    type_field(): Type_fieldContext[];
+    type_field(i: number): Type_fieldContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_fieldContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    VARIP(): antlr.TerminalNode | null;
+    type_qual(): Type_qualContext | null;
+    field_type(): Field_typeContext | null;
+    DEFINE(): antlr.TerminalNode | null;
+    arith_expr(): Arith_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Method_def_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    METHOD(): antlr.TerminalNode;
+    fun_def_stmt(): Fun_def_stmtContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Enum_def_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ENUM(): antlr.TerminalNode;
+    id(): IdContext;
+    enum_body(): Enum_bodyContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Enum_bodyContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BEGIN(): antlr.TerminalNode;
+    END(): antlr.TerminalNode;
+    enum_field(): Enum_fieldContext[];
+    enum_field(i: number): Enum_fieldContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Enum_fieldContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    DEFINE(): antlr.TerminalNode | null;
+    arith_expr(): Arith_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Import_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    IMPORT(): antlr.TerminalNode;
+    import_path(): Import_pathContext;
+    AS(): antlr.TerminalNode | null;
+    id(): IdContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Import_pathContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    import_user(): Import_userContext;
+    DIV(): antlr.TerminalNode[];
+    DIV(i: number): antlr.TerminalNode | null;
+    id(): IdContext[];
+    id(i: number): IdContext | null;
+    INT_LITERAL(): antlr.TerminalNode[];
+    INT_LITERAL(i: number): antlr.TerminalNode | null;
+    FLOAT_LITERAL(): antlr.TerminalNode[];
+    FLOAT_LITERAL(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Import_userContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    user_part(): User_partContext[];
+    user_part(i: number): User_partContext | null;
+    MINUS(): antlr.TerminalNode[];
+    MINUS(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class User_partContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext | null;
+    INT_LITERAL(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_paramContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    type_qual(): Type_qualContext | null;
+    field_type(): Field_typeContext | null;
+    DEFINE(): antlr.TerminalNode | null;
+    arith_expr(): Arith_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_argsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LT(): antlr.TerminalNode;
+    type_arg(): Type_argContext[];
+    type_arg(i: number): Type_argContext | null;
+    GT(): antlr.TerminalNode;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_argContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    type_name(): Type_nameContext | null;
+    id(): IdContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class For_in_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    FOR_STMT(): antlr.TerminalNode;
+    IN(): antlr.TerminalNode;
+    ternary_expr(): Ternary_exprContext;
+    stmts_block(): Stmts_blockContext;
+    ids_array(): Ids_arrayContext | null;
+    id(): IdContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Call_suffixContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    DOT(): antlr.TerminalNode;
+    id(): IdContext;
+    LPAR(): antlr.TerminalNode | null;
+    RPAR(): antlr.TerminalNode | null;
+    type_args(): Type_argsContext | null;
+    fun_actual_args(): Fun_actual_argsContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_callContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    LPAR(): antlr.TerminalNode;
+    RPAR(): antlr.TerminalNode;
+    type_args(): Type_argsContext | null;
+    fun_actual_args(): Fun_actual_argsContext | null;
+    call_suffix(): Call_suffixContext[];
+    call_suffix(i: number): Call_suffixContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class AtomContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    fun_call(): Fun_callContext | null;
+    id(): IdContext | null;
+    literal(): LiteralContext | null;
+    call_suffix(): Call_suffixContext[];
+    call_suffix(i: number): Call_suffixContext | null;
+    LPAR(): antlr.TerminalNode | null;
+    arith_expr(): Arith_exprContext | null;
+    RPAR(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class StmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    import_stmt(): Import_stmtContext | null;
+    export_stmt(): Export_stmtContext | null;
+    type_def_stmt(): Type_def_stmtContext | null;
+    enum_def_stmt(): Enum_def_stmtContext | null;
+    method_def_stmt(): Method_def_stmtContext | null;
+    fun_def_stmt(): Fun_def_stmtContext | null;
+    global_stmt(): Global_stmtContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_headContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LPAR(): antlr.TerminalNode;
+    RPAR(): antlr.TerminalNode;
+    fun_param(): Fun_paramContext[];
+    fun_param(i: number): Fun_paramContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Var_defContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    DEFINE(): antlr.TerminalNode;
+    arith_expr(): Arith_exprContext;
+    decl_mod(): Decl_modContext | null;
+    type_qual(): Type_qualContext | null;
+    field_type(): Field_typeContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Var_defsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ids_array(): Ids_arrayContext;
+    DEFINE(): antlr.TerminalNode;
+    arith_expr(): Arith_exprContext;
+    decl_mod(): Decl_modContext | null;
+    type_qual(): Type_qualContext | null;
+    field_type(): Field_typeContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Id_partContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ID(): antlr.TerminalNode | null;
+    SERIES(): antlr.TerminalNode | null;
+    SIMPLE(): antlr.TerminalNode | null;
+    CONST(): antlr.TerminalNode | null;
+    INT_TYPE(): antlr.TerminalNode | null;
+    FLOAT_TYPE(): antlr.TerminalNode | null;
+    BOOL_TYPE(): antlr.TerminalNode | null;
+    STRING_TYPE(): antlr.TerminalNode | null;
+    COLOR_TYPE(): antlr.TerminalNode | null;
+    LINE_TYPE(): antlr.TerminalNode | null;
+    LABEL_TYPE(): antlr.TerminalNode | null;
+    BOX_TYPE(): antlr.TerminalNode | null;
+    TABLE_TYPE(): antlr.TerminalNode | null;
+    AS(): antlr.TerminalNode | null;
+    TYPE(): antlr.TerminalNode | null;
+    METHOD(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Arith_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ternary_expr(): Ternary_exprContext | null;
+    if_expr(): If_exprContext | null;
+    for_expr(): For_exprContext | null;
+    for_in_expr(): For_in_exprContext | null;
+    switch_expr(): Switch_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Decl_modContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    VAR(): antlr.TerminalNode | null;
+    VARIP(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_qualContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    SERIES(): antlr.TerminalNode | null;
+    SIMPLE(): antlr.TerminalNode | null;
+    CONST(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Type_nameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    INT_TYPE(): antlr.TerminalNode | null;
+    FLOAT_TYPE(): antlr.TerminalNode | null;
+    BOOL_TYPE(): antlr.TerminalNode | null;
+    STRING_TYPE(): antlr.TerminalNode | null;
+    COLOR_TYPE(): antlr.TerminalNode | null;
+    LINE_TYPE(): antlr.TerminalNode | null;
+    LABEL_TYPE(): antlr.TerminalNode | null;
+    BOX_TYPE(): antlr.TerminalNode | null;
+    TABLE_TYPE(): antlr.TerminalNode | null;
+    LSQBR(): antlr.TerminalNode | null;
+    RSQBR(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Compound_assign_opContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    PLUS_ASSIGN(): antlr.TerminalNode | null;
+    MINUS_ASSIGN(): antlr.TerminalNode | null;
+    MUL_ASSIGN(): antlr.TerminalNode | null;
+    DIV_ASSIGN(): antlr.TerminalNode | null;
+    MOD_ASSIGN(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Var_assignContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    arith_expr(): Arith_exprContext;
+    ASSIGN(): antlr.TerminalNode | null;
+    compound_assign_op(): Compound_assign_opContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class If_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    IF_COND(): antlr.TerminalNode;
+    ternary_expr(): Ternary_exprContext;
+    stmts_block(): Stmts_blockContext[];
+    stmts_block(i: number): Stmts_blockContext | null;
+    IF_COND_ELSE(): antlr.TerminalNode | null;
+    if_expr(): If_exprContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Pos_argContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    arith_expr(): Arith_exprContext | null;
+    arith_exprs(): Arith_exprsContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Pos_argsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    pos_arg(): Pos_argContext[];
+    pos_arg(i: number): Pos_argContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Pine_scriptContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    EOF(): antlr.TerminalNode;
+    stmt(): StmtContext[];
+    stmt(i: number): StmtContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Global_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    global_stmt_content(): Global_stmt_contentContext[];
+    global_stmt_content(i: number): Global_stmt_contentContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_def_stmtContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    fun_def_singleline(): Fun_def_singlelineContext | null;
+    fun_def_multiline(): Fun_def_multilineContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_def_singlelineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    fun_head(): Fun_headContext;
+    ARROW(): antlr.TerminalNode;
+    fun_body_singleline(): Fun_body_singlelineContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_def_multilineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    fun_head(): Fun_headContext;
+    ARROW(): antlr.TerminalNode;
+    fun_body_multiline(): Fun_body_multilineContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_body_singlelineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    local_stmt_singleline(): Local_stmt_singlelineContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Local_stmt_singlelineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    local_stmt_content(): Local_stmt_contentContext[];
+    local_stmt_content(i: number): Local_stmt_contentContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Loop_breakContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BREAK(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Loop_continueContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    CONTINUE(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_body_multilineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    local_stmts_multiline(): Local_stmts_multilineContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Local_stmts_multilineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    BEGIN(): antlr.TerminalNode;
+    local_stmts_list(): Local_stmts_listContext;
+    END(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Local_stmts_listContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    local_stmt_multiline(): Local_stmt_multilineContext[];
+    local_stmt_multiline(i: number): Local_stmt_multilineContext | null;
+    LEND(): antlr.TerminalNode[];
+    LEND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Local_stmt_multilineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    local_stmt_content(): Local_stmt_contentContext[];
+    local_stmt_content(i: number): Local_stmt_contentContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Ids_arrayContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LSQBR(): antlr.TerminalNode;
+    id(): IdContext[];
+    id(i: number): IdContext | null;
+    RSQBR(): antlr.TerminalNode;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Arith_exprsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    LSQBR(): antlr.TerminalNode;
+    arith_expr(): Arith_exprContext[];
+    arith_expr(i: number): Arith_exprContext | null;
+    RSQBR(): antlr.TerminalNode;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class For_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    FOR_STMT(): antlr.TerminalNode;
+    var_def(): Var_defContext;
+    FOR_STMT_TO(): antlr.TerminalNode;
+    ternary_expr(): Ternary_exprContext[];
+    ternary_expr(i: number): Ternary_exprContext | null;
+    stmts_block(): Stmts_blockContext;
+    FOR_STMT_BY(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Stmts_blockContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    fun_body_multiline(): Fun_body_multilineContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Ternary_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    or_expr(): Or_exprContext;
+    COND(): antlr.TerminalNode | null;
+    ternary_expr(): Ternary_exprContext[];
+    ternary_expr(i: number): Ternary_exprContext | null;
+    COND_ELSE(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Or_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    and_expr(): And_exprContext[];
+    and_expr(i: number): And_exprContext | null;
+    OR(): antlr.TerminalNode[];
+    OR(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class And_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    eq_expr(): Eq_exprContext[];
+    eq_expr(i: number): Eq_exprContext | null;
+    AND(): antlr.TerminalNode[];
+    AND(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Eq_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    cmp_expr(): Cmp_exprContext[];
+    cmp_expr(i: number): Cmp_exprContext | null;
+    EQ(): antlr.TerminalNode[];
+    EQ(i: number): antlr.TerminalNode | null;
+    NEQ(): antlr.TerminalNode[];
+    NEQ(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Cmp_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    add_expr(): Add_exprContext[];
+    add_expr(i: number): Add_exprContext | null;
+    GT(): antlr.TerminalNode[];
+    GT(i: number): antlr.TerminalNode | null;
+    GE(): antlr.TerminalNode[];
+    GE(i: number): antlr.TerminalNode | null;
+    LT(): antlr.TerminalNode[];
+    LT(i: number): antlr.TerminalNode | null;
+    LE(): antlr.TerminalNode[];
+    LE(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Add_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    mult_expr(): Mult_exprContext[];
+    mult_expr(i: number): Mult_exprContext | null;
+    PLUS(): antlr.TerminalNode[];
+    PLUS(i: number): antlr.TerminalNode | null;
+    MINUS(): antlr.TerminalNode[];
+    MINUS(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Mult_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    unary_expr(): Unary_exprContext[];
+    unary_expr(i: number): Unary_exprContext | null;
+    MUL(): antlr.TerminalNode[];
+    MUL(i: number): antlr.TerminalNode | null;
+    DIV(): antlr.TerminalNode[];
+    DIV(i: number): antlr.TerminalNode | null;
+    MOD(): antlr.TerminalNode[];
+    MOD(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Unary_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    sqbr_expr(): Sqbr_exprContext;
+    NOT(): antlr.TerminalNode | null;
+    PLUS(): antlr.TerminalNode | null;
+    MINUS(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Sqbr_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    atom(): AtomContext;
+    LSQBR(): antlr.TerminalNode | null;
+    arith_expr(): Arith_exprContext | null;
+    RSQBR(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Fun_actual_argsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    kw_args(): Kw_argsContext | null;
+    pos_args(): Pos_argsContext | null;
+    COMMA(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Kw_argsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    kw_arg(): Kw_argContext[];
+    kw_arg(i: number): Kw_argContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Kw_argContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    id(): IdContext;
+    DEFINE(): antlr.TerminalNode;
+    arith_expr(): Arith_exprContext | null;
+    arith_exprs(): Arith_exprsContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class LiteralContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    num_literal(): Num_literalContext | null;
+    other_literal(): Other_literalContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}
+export declare class Num_literalContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    INT_LITERAL(): antlr.TerminalNode | null;
+    FLOAT_LITERAL(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: PineV6ParserVisitor<Result>): Result | null;
+}