@cubejs-backend/schema-compiler 1.3.56 → 1.3.57

package/dist/src/parser/Python3Parser.d.ts

@@ -1,13 +1,7 @@
-import { ATN } from "antlr4ts/atn/ATN";
-import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
-import { Parser } from "antlr4ts/Parser";
-import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
-import { TerminalNode } from "antlr4ts/tree/TerminalNode";
-import { TokenStream } from "antlr4ts/TokenStream";
-import { Vocabulary } from "antlr4ts/Vocabulary";
-import { Python3ParserListener } from "./Python3ParserListener";
-import { Python3ParserVisitor } from "./Python3ParserVisitor";
-export declare class Python3Parser extends Parser {
+import { ATN, DFA, FailedPredicateException, Parser, ParserRuleContext, TerminalNode, TokenStream } from 'antlr4';
+import Python3ParserListener from "./Python3ParserListener.js";
+import Python3ParserVisitor from "./Python3ParserVisitor.js";
+export default class Python3Parser extends Parser {
     static readonly INDENT = 1;
     static readonly DEDENT = 2;
     static readonly SINGLE_QUOTE_SHORT_TEMPLATE_STRING_START = 3;
@@ -120,6 +114,7 @@ export declare class Python3Parser extends Parser {
     static readonly DOUBLE_QUOTE_SHORT_TEMPLATE_STRING_END = 110;
     static readonly DOUBLE_QUOTE_LONG_TEMPLATE_STRING_END = 111;
     static readonly DOUBLE_QUOTE_STRING_ATOM = 112;
+    static readonly EOF: number;
     static readonly RULE_file_input = 0;
     static readonly RULE_single_input = 1;
     static readonly RULE_eval_input = 2;
@@ -210,14 +205,14 @@ export declare class Python3Parser extends Parser {
     static readonly RULE_string_template = 87;
     static readonly RULE_single_string_template_atom = 88;
     static readonly RULE_double_string_template_atom = 89;
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
-    private static readonly _LITERAL_NAMES;
-    private static readonly _SYMBOLIC_NAMES;
-    static readonly VOCABULARY: Vocabulary;
-    get vocabulary(): Vocabulary;
     get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
     get ruleNames(): string[];
-    get serializedATN(): string;
+    get serializedATN(): number[];
     protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
     constructor(input: TokenStream);
     file_input(): File_inputContext;
@@ -310,1093 +305,1090 @@ export declare class Python3Parser extends Parser {
     string_template(): String_templateContext;
     single_string_template_atom(): Single_string_template_atomContext;
     double_string_template_atom(): Double_string_template_atomContext;
-    private static readonly _serializedATNSegments;
-    private static readonly _serializedATNSegment0;
-    private static readonly _serializedATNSegment1;
-    private static readonly _serializedATNSegment2;
-    static readonly _serializedATN: string;
-    static __ATN: ATN;
+    static readonly _serializedATN: number[];
+    private static __ATN;
     static get _ATN(): ATN;
+    static DecisionsToDFA: DFA[];
 }
 export declare class File_inputContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     EOF(): TerminalNode;
-    NEWLINE(): TerminalNode[];
+    NEWLINE_list(): TerminalNode[];
     NEWLINE(i: number): TerminalNode;
-    stmt(): StmtContext[];
+    stmt_list(): StmtContext[];
     stmt(i: number): StmtContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Single_inputContext extends ParserRuleContext {
-    NEWLINE(): TerminalNode | undefined;
-    simple_stmt(): Simple_stmtContext | undefined;
-    compound_stmt(): Compound_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    NEWLINE(): TerminalNode;
+    simple_stmt(): Simple_stmtContext;
+    compound_stmt(): Compound_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Eval_inputContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     testlist(): TestlistContext;
     EOF(): TerminalNode;
-    NEWLINE(): TerminalNode[];
+    NEWLINE_list(): TerminalNode[];
     NEWLINE(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class DecoratorContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     AT(): TerminalNode;
     dotted_name(): Dotted_nameContext;
     NEWLINE(): TerminalNode;
-    OPEN_PAREN(): TerminalNode | undefined;
-    CLOSE_PAREN(): TerminalNode | undefined;
-    arglist(): ArglistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    OPEN_PAREN(): TerminalNode;
+    CLOSE_PAREN(): TerminalNode;
+    arglist(): ArglistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class DecoratorsContext extends ParserRuleContext {
-    decorator(): DecoratorContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    decorator_list(): DecoratorContext[];
     decorator(i: number): DecoratorContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class DecoratedContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     decorators(): DecoratorsContext;
-    classdef(): ClassdefContext | undefined;
-    funcdef(): FuncdefContext | undefined;
-    async_funcdef(): Async_funcdefContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    classdef(): ClassdefContext;
+    funcdef(): FuncdefContext;
+    async_funcdef(): Async_funcdefContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Async_funcdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     ASYNC(): TerminalNode;
     funcdef(): FuncdefContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class FuncdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     DEF(): TerminalNode;
     NAME(): TerminalNode;
     parameters(): ParametersContext;
     COLON(): TerminalNode;
     suite(): SuiteContext;
-    ARROW(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ARROW(): TerminalNode;
+    test(): TestContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ParametersContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     OPEN_PAREN(): TerminalNode;
     CLOSE_PAREN(): TerminalNode;
-    typedargslist(): TypedargslistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    typedargslist(): TypedargslistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TypedargslistContext extends ParserRuleContext {
-    tfpdef(): TfpdefContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    tfpdef_list(): TfpdefContext[];
     tfpdef(i: number): TfpdefContext;
-    STAR(): TerminalNode | undefined;
-    POWER(): TerminalNode | undefined;
-    ASSIGN(): TerminalNode[];
+    STAR(): TerminalNode;
+    POWER(): TerminalNode;
+    ASSIGN_list(): TerminalNode[];
     ASSIGN(i: number): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TfpdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     NAME(): TerminalNode;
-    COLON(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    COLON(): TerminalNode;
+    test(): TestContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class VarargslistContext extends ParserRuleContext {
-    vfpdef(): VfpdefContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    vfpdef_list(): VfpdefContext[];
     vfpdef(i: number): VfpdefContext;
-    STAR(): TerminalNode | undefined;
-    POWER(): TerminalNode | undefined;
-    ASSIGN(): TerminalNode[];
+    STAR(): TerminalNode;
+    POWER(): TerminalNode;
+    ASSIGN_list(): TerminalNode[];
     ASSIGN(i: number): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class VfpdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     NAME(): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class StmtContext extends ParserRuleContext {
-    simple_stmt(): Simple_stmtContext | undefined;
-    compound_stmt(): Compound_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    simple_stmt(): Simple_stmtContext;
+    compound_stmt(): Compound_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Simple_stmtContext extends ParserRuleContext {
-    small_stmt(): Small_stmtContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    small_stmt_list(): Small_stmtContext[];
     small_stmt(i: number): Small_stmtContext;
     NEWLINE(): TerminalNode;
-    SEMI_COLON(): TerminalNode[];
+    SEMI_COLON_list(): TerminalNode[];
     SEMI_COLON(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Small_stmtContext extends ParserRuleContext {
-    expr_stmt(): Expr_stmtContext | undefined;
-    del_stmt(): Del_stmtContext | undefined;
-    pass_stmt(): Pass_stmtContext | undefined;
-    flow_stmt(): Flow_stmtContext | undefined;
-    import_stmt(): Import_stmtContext | undefined;
-    global_stmt(): Global_stmtContext | undefined;
-    nonlocal_stmt(): Nonlocal_stmtContext | undefined;
-    assert_stmt(): Assert_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    expr_stmt(): Expr_stmtContext;
+    del_stmt(): Del_stmtContext;
+    pass_stmt(): Pass_stmtContext;
+    flow_stmt(): Flow_stmtContext;
+    import_stmt(): Import_stmtContext;
+    global_stmt(): Global_stmtContext;
+    nonlocal_stmt(): Nonlocal_stmtContext;
+    assert_stmt(): Assert_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Expr_stmtContext extends ParserRuleContext {
-    testlist_star_expr(): Testlist_star_exprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    testlist_star_expr_list(): Testlist_star_exprContext[];
     testlist_star_expr(i: number): Testlist_star_exprContext;
-    annassign(): AnnassignContext | undefined;
-    augassign(): AugassignContext | undefined;
-    yield_expr(): Yield_exprContext[];
+    annassign(): AnnassignContext;
+    augassign(): AugassignContext;
+    yield_expr_list(): Yield_exprContext[];
     yield_expr(i: number): Yield_exprContext;
-    testlist(): TestlistContext | undefined;
-    ASSIGN(): TerminalNode[];
+    testlist(): TestlistContext;
+    ASSIGN_list(): TerminalNode[];
     ASSIGN(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class AnnassignContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     COLON(): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    ASSIGN(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ASSIGN(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Testlist_star_exprContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    star_expr(): Star_exprContext[];
+    star_expr_list(): Star_exprContext[];
     star_expr(i: number): Star_exprContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class AugassignContext extends ParserRuleContext {
-    ADD_ASSIGN(): TerminalNode | undefined;
-    SUB_ASSIGN(): TerminalNode | undefined;
-    MULT_ASSIGN(): TerminalNode | undefined;
-    AT_ASSIGN(): TerminalNode | undefined;
-    DIV_ASSIGN(): TerminalNode | undefined;
-    MOD_ASSIGN(): TerminalNode | undefined;
-    AND_ASSIGN(): TerminalNode | undefined;
-    OR_ASSIGN(): TerminalNode | undefined;
-    XOR_ASSIGN(): TerminalNode | undefined;
-    LEFT_SHIFT_ASSIGN(): TerminalNode | undefined;
-    RIGHT_SHIFT_ASSIGN(): TerminalNode | undefined;
-    POWER_ASSIGN(): TerminalNode | undefined;
-    IDIV_ASSIGN(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    ADD_ASSIGN(): TerminalNode;
+    SUB_ASSIGN(): TerminalNode;
+    MULT_ASSIGN(): TerminalNode;
+    AT_ASSIGN(): TerminalNode;
+    DIV_ASSIGN(): TerminalNode;
+    MOD_ASSIGN(): TerminalNode;
+    AND_ASSIGN(): TerminalNode;
+    OR_ASSIGN(): TerminalNode;
+    XOR_ASSIGN(): TerminalNode;
+    LEFT_SHIFT_ASSIGN(): TerminalNode;
+    RIGHT_SHIFT_ASSIGN(): TerminalNode;
+    POWER_ASSIGN(): TerminalNode;
+    IDIV_ASSIGN(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Del_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     DEL(): TerminalNode;
     exprlist(): ExprlistContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Pass_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     PASS(): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Flow_stmtContext extends ParserRuleContext {
-    break_stmt(): Break_stmtContext | undefined;
-    continue_stmt(): Continue_stmtContext | undefined;
-    return_stmt(): Return_stmtContext | undefined;
-    raise_stmt(): Raise_stmtContext | undefined;
-    yield_stmt(): Yield_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    break_stmt(): Break_stmtContext;
+    continue_stmt(): Continue_stmtContext;
+    return_stmt(): Return_stmtContext;
+    raise_stmt(): Raise_stmtContext;
+    yield_stmt(): Yield_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Break_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     BREAK(): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Continue_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     CONTINUE(): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Return_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     RETURN(): TerminalNode;
-    testlist(): TestlistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    testlist(): TestlistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Yield_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     yield_expr(): Yield_exprContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Raise_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     RAISE(): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    FROM(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    FROM(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Import_stmtContext extends ParserRuleContext {
-    import_name(): Import_nameContext | undefined;
-    import_from(): Import_fromContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    import_name(): Import_nameContext;
+    import_from(): Import_fromContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Import_nameContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     IMPORT(): TerminalNode;
     dotted_as_names(): Dotted_as_namesContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Import_fromContext extends ParserRuleContext {
-    FROM(): TerminalNode | undefined;
-    IMPORT(): TerminalNode | undefined;
-    dotted_name(): Dotted_nameContext | undefined;
-    STAR(): TerminalNode | undefined;
-    OPEN_PAREN(): TerminalNode | undefined;
-    import_as_names(): Import_as_namesContext | undefined;
-    CLOSE_PAREN(): TerminalNode | undefined;
-    DOT(): TerminalNode[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    FROM(): TerminalNode;
+    IMPORT(): TerminalNode;
+    dotted_name(): Dotted_nameContext;
+    STAR(): TerminalNode;
+    OPEN_PAREN(): TerminalNode;
+    import_as_names(): Import_as_namesContext;
+    CLOSE_PAREN(): TerminalNode;
+    DOT_list(): TerminalNode[];
     DOT(i: number): TerminalNode;
-    ELLIPSIS(): TerminalNode[];
+    ELLIPSIS_list(): TerminalNode[];
     ELLIPSIS(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Import_as_nameContext extends ParserRuleContext {
-    NAME(): TerminalNode[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    NAME_list(): TerminalNode[];
     NAME(i: number): TerminalNode;
-    AS(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    AS(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Dotted_as_nameContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     dotted_name(): Dotted_nameContext;
-    AS(): TerminalNode | undefined;
-    NAME(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    AS(): TerminalNode;
+    NAME(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Import_as_namesContext extends ParserRuleContext {
-    import_as_name(): Import_as_nameContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    import_as_name_list(): Import_as_nameContext[];
     import_as_name(i: number): Import_as_nameContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Dotted_as_namesContext extends ParserRuleContext {
-    dotted_as_name(): Dotted_as_nameContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    dotted_as_name_list(): Dotted_as_nameContext[];
     dotted_as_name(i: number): Dotted_as_nameContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Dotted_nameContext extends ParserRuleContext {
-    NAME(): TerminalNode[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    NAME_list(): TerminalNode[];
     NAME(i: number): TerminalNode;
-    DOT(): TerminalNode[];
+    DOT_list(): TerminalNode[];
     DOT(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Global_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     GLOBAL(): TerminalNode;
-    NAME(): TerminalNode[];
+    NAME_list(): TerminalNode[];
     NAME(i: number): TerminalNode;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Nonlocal_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     NONLOCAL(): TerminalNode;
-    NAME(): TerminalNode[];
+    NAME_list(): TerminalNode[];
     NAME(i: number): TerminalNode;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Assert_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     ASSERT(): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COMMA(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    COMMA(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Compound_stmtContext extends ParserRuleContext {
-    if_stmt(): If_stmtContext | undefined;
-    while_stmt(): While_stmtContext | undefined;
-    for_stmt(): For_stmtContext | undefined;
-    try_stmt(): Try_stmtContext | undefined;
-    with_stmt(): With_stmtContext | undefined;
-    funcdef(): FuncdefContext | undefined;
-    classdef(): ClassdefContext | undefined;
-    decorated(): DecoratedContext | undefined;
-    async_stmt(): Async_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    if_stmt(): If_stmtContext;
+    while_stmt(): While_stmtContext;
+    for_stmt(): For_stmtContext;
+    try_stmt(): Try_stmtContext;
+    with_stmt(): With_stmtContext;
+    funcdef(): FuncdefContext;
+    classdef(): ClassdefContext;
+    decorated(): DecoratedContext;
+    async_stmt(): Async_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Async_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     ASYNC(): TerminalNode;
-    funcdef(): FuncdefContext | undefined;
-    with_stmt(): With_stmtContext | undefined;
-    for_stmt(): For_stmtContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    funcdef(): FuncdefContext;
+    with_stmt(): With_stmtContext;
+    for_stmt(): For_stmtContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class If_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     IF(): TerminalNode;
-    test(): TestContext[];
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COLON(): TerminalNode[];
+    COLON_list(): TerminalNode[];
     COLON(i: number): TerminalNode;
-    suite(): SuiteContext[];
+    suite_list(): SuiteContext[];
     suite(i: number): SuiteContext;
-    ELIF(): TerminalNode[];
+    ELIF_list(): TerminalNode[];
     ELIF(i: number): TerminalNode;
-    ELSE(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ELSE(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class While_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     WHILE(): TerminalNode;
     test(): TestContext;
-    COLON(): TerminalNode[];
+    COLON_list(): TerminalNode[];
     COLON(i: number): TerminalNode;
-    suite(): SuiteContext[];
+    suite_list(): SuiteContext[];
     suite(i: number): SuiteContext;
-    ELSE(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ELSE(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class For_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     FOR(): TerminalNode;
     exprlist(): ExprlistContext;
     IN(): TerminalNode;
     testlist(): TestlistContext;
-    COLON(): TerminalNode[];
+    COLON_list(): TerminalNode[];
     COLON(i: number): TerminalNode;
-    suite(): SuiteContext[];
+    suite_list(): SuiteContext[];
     suite(i: number): SuiteContext;
-    ELSE(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ELSE(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Try_stmtContext extends ParserRuleContext {
-    TRY(): TerminalNode | undefined;
-    COLON(): TerminalNode[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    TRY(): TerminalNode;
+    COLON_list(): TerminalNode[];
     COLON(i: number): TerminalNode;
-    suite(): SuiteContext[];
+    suite_list(): SuiteContext[];
     suite(i: number): SuiteContext;
-    FINALLY(): TerminalNode | undefined;
-    except_clause(): Except_clauseContext[];
+    FINALLY(): TerminalNode;
+    except_clause_list(): Except_clauseContext[];
     except_clause(i: number): Except_clauseContext;
-    ELSE(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ELSE(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class With_stmtContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     WITH(): TerminalNode;
-    with_item(): With_itemContext[];
+    with_item_list(): With_itemContext[];
     with_item(i: number): With_itemContext;
     COLON(): TerminalNode;
     suite(): SuiteContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class With_itemContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     test(): TestContext;
-    AS(): TerminalNode | undefined;
-    expr(): ExprContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    AS(): TerminalNode;
+    expr(): ExprContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Except_clauseContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     EXCEPT(): TerminalNode;
-    test(): TestContext | undefined;
-    AS(): TerminalNode | undefined;
-    NAME(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    test(): TestContext;
+    AS(): TerminalNode;
+    NAME(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class SuiteContext extends ParserRuleContext {
-    simple_stmt(): Simple_stmtContext | undefined;
-    NEWLINE(): TerminalNode | undefined;
-    INDENT(): TerminalNode | undefined;
-    DEDENT(): TerminalNode | undefined;
-    stmt(): StmtContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    simple_stmt(): Simple_stmtContext;
+    NEWLINE(): TerminalNode;
+    INDENT(): TerminalNode;
+    DEDENT(): TerminalNode;
+    stmt_list(): StmtContext[];
     stmt(i: number): StmtContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TestContext extends ParserRuleContext {
-    or_test(): Or_testContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    or_test_list(): Or_testContext[];
     or_test(i: number): Or_testContext;
-    IF(): TerminalNode | undefined;
-    ELSE(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    lambdef(): LambdefContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    IF(): TerminalNode;
+    ELSE(): TerminalNode;
+    test(): TestContext;
+    lambdef(): LambdefContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Test_nocondContext extends ParserRuleContext {
-    or_test(): Or_testContext | undefined;
-    lambdef_nocond(): Lambdef_nocondContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    or_test(): Or_testContext;
+    lambdef_nocond(): Lambdef_nocondContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class LambdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     LAMBDA(): TerminalNode;
     COLON(): TerminalNode;
     test(): TestContext;
-    varargslist(): VarargslistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    varargslist(): VarargslistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Lambdef_nocondContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     LAMBDA(): TerminalNode;
     COLON(): TerminalNode;
     test_nocond(): Test_nocondContext;
-    varargslist(): VarargslistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    varargslist(): VarargslistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Or_testContext extends ParserRuleContext {
-    and_test(): And_testContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    and_test_list(): And_testContext[];
     and_test(i: number): And_testContext;
-    OR(): TerminalNode[];
+    OR_list(): TerminalNode[];
     OR(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class And_testContext extends ParserRuleContext {
-    not_test(): Not_testContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    not_test_list(): Not_testContext[];
     not_test(i: number): Not_testContext;
-    AND(): TerminalNode[];
+    AND_list(): TerminalNode[];
     AND(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Not_testContext extends ParserRuleContext {
-    NOT(): TerminalNode | undefined;
-    not_test(): Not_testContext | undefined;
-    comparison(): ComparisonContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    NOT(): TerminalNode;
+    not_test(): Not_testContext;
+    comparison(): ComparisonContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ComparisonContext extends ParserRuleContext {
-    expr(): ExprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    expr_list(): ExprContext[];
     expr(i: number): ExprContext;
-    comp_op(): Comp_opContext[];
+    comp_op_list(): Comp_opContext[];
     comp_op(i: number): Comp_opContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Comp_opContext extends ParserRuleContext {
-    LESS_THAN(): TerminalNode | undefined;
-    GREATER_THAN(): TerminalNode | undefined;
-    EQUALS(): TerminalNode | undefined;
-    GT_EQ(): TerminalNode | undefined;
-    LT_EQ(): TerminalNode | undefined;
-    NOT_EQ_1(): TerminalNode | undefined;
-    NOT_EQ_2(): TerminalNode | undefined;
-    IN(): TerminalNode | undefined;
-    NOT(): TerminalNode | undefined;
-    IS(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    LESS_THAN(): TerminalNode;
+    GREATER_THAN(): TerminalNode;
+    EQUALS(): TerminalNode;
+    GT_EQ(): TerminalNode;
+    LT_EQ(): TerminalNode;
+    NOT_EQ_1(): TerminalNode;
+    NOT_EQ_2(): TerminalNode;
+    IN(): TerminalNode;
+    NOT(): TerminalNode;
+    IS(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Star_exprContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     STAR(): TerminalNode;
     expr(): ExprContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ExprContext extends ParserRuleContext {
-    xor_expr(): Xor_exprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    xor_expr_list(): Xor_exprContext[];
     xor_expr(i: number): Xor_exprContext;
-    OR_OP(): TerminalNode[];
+    OR_OP_list(): TerminalNode[];
     OR_OP(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Xor_exprContext extends ParserRuleContext {
-    and_expr(): And_exprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    and_expr_list(): And_exprContext[];
     and_expr(i: number): And_exprContext;
-    XOR(): TerminalNode[];
+    XOR_list(): TerminalNode[];
     XOR(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class And_exprContext extends ParserRuleContext {
-    shift_expr(): Shift_exprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    shift_expr_list(): Shift_exprContext[];
     shift_expr(i: number): Shift_exprContext;
-    AND_OP(): TerminalNode[];
+    AND_OP_list(): TerminalNode[];
     AND_OP(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Shift_exprContext extends ParserRuleContext {
-    arith_expr(): Arith_exprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    arith_expr_list(): Arith_exprContext[];
     arith_expr(i: number): Arith_exprContext;
-    LEFT_SHIFT(): TerminalNode[];
+    LEFT_SHIFT_list(): TerminalNode[];
     LEFT_SHIFT(i: number): TerminalNode;
-    RIGHT_SHIFT(): TerminalNode[];
+    RIGHT_SHIFT_list(): TerminalNode[];
     RIGHT_SHIFT(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Arith_exprContext extends ParserRuleContext {
-    term(): TermContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    term_list(): TermContext[];
     term(i: number): TermContext;
-    ADD(): TerminalNode[];
+    ADD_list(): TerminalNode[];
     ADD(i: number): TerminalNode;
-    MINUS(): TerminalNode[];
+    MINUS_list(): TerminalNode[];
     MINUS(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TermContext extends ParserRuleContext {
-    factor(): FactorContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    factor_list(): FactorContext[];
     factor(i: number): FactorContext;
-    STAR(): TerminalNode[];
+    STAR_list(): TerminalNode[];
     STAR(i: number): TerminalNode;
-    AT(): TerminalNode[];
+    AT_list(): TerminalNode[];
     AT(i: number): TerminalNode;
-    DIV(): TerminalNode[];
+    DIV_list(): TerminalNode[];
     DIV(i: number): TerminalNode;
-    MOD(): TerminalNode[];
+    MOD_list(): TerminalNode[];
     MOD(i: number): TerminalNode;
-    IDIV(): TerminalNode[];
+    IDIV_list(): TerminalNode[];
     IDIV(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class FactorContext extends ParserRuleContext {
-    factor(): FactorContext | undefined;
-    ADD(): TerminalNode | undefined;
-    MINUS(): TerminalNode | undefined;
-    NOT_OP(): TerminalNode | undefined;
-    power(): PowerContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    factor(): FactorContext;
+    ADD(): TerminalNode;
+    MINUS(): TerminalNode;
+    NOT_OP(): TerminalNode;
+    power(): PowerContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class PowerContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     atom_expr(): Atom_exprContext;
-    POWER(): TerminalNode | undefined;
-    factor(): FactorContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    POWER(): TerminalNode;
+    factor(): FactorContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Atom_exprContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     atom(): AtomContext;
-    AWAIT(): TerminalNode | undefined;
-    trailer(): TrailerContext[];
+    AWAIT(): TerminalNode;
+    trailer_list(): TrailerContext[];
     trailer(i: number): TrailerContext;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class AtomContext extends ParserRuleContext {
-    OPEN_PAREN(): TerminalNode | undefined;
-    CLOSE_PAREN(): TerminalNode | undefined;
-    OPEN_BRACK(): TerminalNode | undefined;
-    CLOSE_BRACK(): TerminalNode | undefined;
-    OPEN_BRACE(): TerminalNode | undefined;
-    CLOSE_BRACE(): TerminalNode | undefined;
-    NAME(): TerminalNode | undefined;
-    NUMBER(): TerminalNode | undefined;
-    ELLIPSIS(): TerminalNode | undefined;
-    NONE(): TerminalNode | undefined;
-    TRUE(): TerminalNode | undefined;
-    FALSE(): TerminalNode | undefined;
-    yield_expr(): Yield_exprContext | undefined;
-    testlist_comp(): Testlist_compContext | undefined;
-    dictorsetmaker(): DictorsetmakerContext | undefined;
-    string_template(): String_templateContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    OPEN_PAREN(): TerminalNode;
+    CLOSE_PAREN(): TerminalNode;
+    OPEN_BRACK(): TerminalNode;
+    CLOSE_BRACK(): TerminalNode;
+    OPEN_BRACE(): TerminalNode;
+    CLOSE_BRACE(): TerminalNode;
+    NAME(): TerminalNode;
+    NUMBER(): TerminalNode;
+    ELLIPSIS(): TerminalNode;
+    NONE(): TerminalNode;
+    TRUE(): TerminalNode;
+    FALSE(): TerminalNode;
+    yield_expr(): Yield_exprContext;
+    testlist_comp(): Testlist_compContext;
+    dictorsetmaker(): DictorsetmakerContext;
+    string_template_list(): String_templateContext[];
     string_template(i: number): String_templateContext;
-    STRING(): TerminalNode[];
+    STRING_list(): TerminalNode[];
     STRING(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Testlist_compContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    star_expr(): Star_exprContext[];
+    star_expr_list(): Star_exprContext[];
     star_expr(i: number): Star_exprContext;
-    comp_for(): Comp_forContext | undefined;
-    COMMA(): TerminalNode[];
+    comp_for(): Comp_forContext;
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TrailerContext extends ParserRuleContext {
-    callArguments(): CallArgumentsContext | undefined;
-    OPEN_BRACK(): TerminalNode | undefined;
-    subscriptlist(): SubscriptlistContext | undefined;
-    CLOSE_BRACK(): TerminalNode | undefined;
-    DOT(): TerminalNode | undefined;
-    NAME(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    callArguments(): CallArgumentsContext;
+    OPEN_BRACK(): TerminalNode;
+    subscriptlist(): SubscriptlistContext;
+    CLOSE_BRACK(): TerminalNode;
+    DOT(): TerminalNode;
+    NAME(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class SubscriptlistContext extends ParserRuleContext {
-    subscript(): SubscriptContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    subscript_list(): SubscriptContext[];
     subscript(i: number): SubscriptContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class SubscriptContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COLON(): TerminalNode | undefined;
-    sliceop(): SliceopContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    COLON(): TerminalNode;
+    sliceop(): SliceopContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class SliceopContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     COLON(): TerminalNode;
-    test(): TestContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    test(): TestContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ExprlistContext extends ParserRuleContext {
-    expr(): ExprContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    expr_list(): ExprContext[];
     expr(i: number): ExprContext;
-    star_expr(): Star_exprContext[];
+    star_expr_list(): Star_exprContext[];
     star_expr(i: number): Star_exprContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class TestlistContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class DictorsetmakerContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    COLON(): TerminalNode[];
+    COLON_list(): TerminalNode[];
     COLON(i: number): TerminalNode;
-    POWER(): TerminalNode[];
+    POWER_list(): TerminalNode[];
     POWER(i: number): TerminalNode;
-    expr(): ExprContext[];
+    expr_list(): ExprContext[];
     expr(i: number): ExprContext;
-    comp_for(): Comp_forContext | undefined;
-    star_expr(): Star_exprContext[];
+    comp_for(): Comp_forContext;
+    star_expr_list(): Star_exprContext[];
     star_expr(i: number): Star_exprContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ClassdefContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     CLASS(): TerminalNode;
     NAME(): TerminalNode;
     COLON(): TerminalNode;
     suite(): SuiteContext;
-    OPEN_PAREN(): TerminalNode | undefined;
-    CLOSE_PAREN(): TerminalNode | undefined;
-    arglist(): ArglistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    OPEN_PAREN(): TerminalNode;
+    CLOSE_PAREN(): TerminalNode;
+    arglist(): ArglistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class CallArgumentsContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     OPEN_PAREN(): TerminalNode;
     CLOSE_PAREN(): TerminalNode;
-    arglist(): ArglistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    arglist(): ArglistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ArglistContext extends ParserRuleContext {
-    argument(): ArgumentContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    argument_list(): ArgumentContext[];
     argument(i: number): ArgumentContext;
-    COMMA(): TerminalNode[];
+    COMMA_list(): TerminalNode[];
     COMMA(i: number): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class ArgumentContext extends ParserRuleContext {
-    test(): TestContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    test_list(): TestContext[];
     test(i: number): TestContext;
-    ASSIGN(): TerminalNode | undefined;
-    POWER(): TerminalNode | undefined;
-    STAR(): TerminalNode | undefined;
-    comp_for(): Comp_forContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ASSIGN(): TerminalNode;
+    POWER(): TerminalNode;
+    STAR(): TerminalNode;
+    comp_for(): Comp_forContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Comp_iterContext extends ParserRuleContext {
-    comp_for(): Comp_forContext | undefined;
-    comp_if(): Comp_ifContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    comp_for(): Comp_forContext;
+    comp_if(): Comp_ifContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Comp_forContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     FOR(): TerminalNode;
     exprlist(): ExprlistContext;
     IN(): TerminalNode;
     or_test(): Or_testContext;
-    ASYNC(): TerminalNode | undefined;
-    comp_iter(): Comp_iterContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    ASYNC(): TerminalNode;
+    comp_iter(): Comp_iterContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Comp_ifContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     IF(): TerminalNode;
     test_nocond(): Test_nocondContext;
-    comp_iter(): Comp_iterContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    comp_iter(): Comp_iterContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Encoding_declContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     NAME(): TerminalNode;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Yield_exprContext extends ParserRuleContext {
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
     YIELD(): TerminalNode;
-    yield_arg(): Yield_argContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    yield_arg(): Yield_argContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Yield_argContext extends ParserRuleContext {
-    FROM(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    testlist(): TestlistContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    FROM(): TerminalNode;
+    test(): TestContext;
+    testlist(): TestlistContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class String_templateContext extends ParserRuleContext {
-    SINGLE_QUOTE_SHORT_TEMPLATE_STRING_START(): TerminalNode | undefined;
-    SINGLE_QUOTE_SHORT_TEMPLATE_STRING_END(): TerminalNode | undefined;
-    single_string_template_atom(): Single_string_template_atomContext[];
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    SINGLE_QUOTE_SHORT_TEMPLATE_STRING_START(): TerminalNode;
+    SINGLE_QUOTE_SHORT_TEMPLATE_STRING_END(): TerminalNode;
+    single_string_template_atom_list(): Single_string_template_atomContext[];
     single_string_template_atom(i: number): Single_string_template_atomContext;
-    SINGLE_QUOTE_LONG_TEMPLATE_STRING_START(): TerminalNode | undefined;
-    SINGLE_QUOTE_LONG_TEMPLATE_STRING_END(): TerminalNode | undefined;
-    DOUBLE_QUOTE_SHORT_TEMPLATE_STRING_START(): TerminalNode | undefined;
-    DOUBLE_QUOTE_SHORT_TEMPLATE_STRING_END(): TerminalNode | undefined;
-    double_string_template_atom(): Double_string_template_atomContext[];
+    SINGLE_QUOTE_LONG_TEMPLATE_STRING_START(): TerminalNode;
+    SINGLE_QUOTE_LONG_TEMPLATE_STRING_END(): TerminalNode;
+    DOUBLE_QUOTE_SHORT_TEMPLATE_STRING_START(): TerminalNode;
+    DOUBLE_QUOTE_SHORT_TEMPLATE_STRING_END(): TerminalNode;
+    double_string_template_atom_list(): Double_string_template_atomContext[];
     double_string_template_atom(i: number): Double_string_template_atomContext;
-    DOUBLE_QUOTE_LONG_TEMPLATE_STRING_START(): TerminalNode | undefined;
-    DOUBLE_QUOTE_LONG_TEMPLATE_STRING_END(): TerminalNode | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    DOUBLE_QUOTE_LONG_TEMPLATE_STRING_START(): TerminalNode;
+    DOUBLE_QUOTE_LONG_TEMPLATE_STRING_END(): TerminalNode;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Single_string_template_atomContext extends ParserRuleContext {
-    SINGLE_QUOTE_STRING_ATOM(): TerminalNode | undefined;
-    OPEN_BRACE(): TerminalNode | undefined;
-    TEMPLATE_CLOSE_BRACE(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    star_expr(): Star_exprContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    SINGLE_QUOTE_STRING_ATOM(): TerminalNode;
+    OPEN_BRACE(): TerminalNode;
+    TEMPLATE_CLOSE_BRACE(): TerminalNode;
+    test(): TestContext;
+    star_expr(): Star_exprContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;
     accept<Result>(visitor: Python3ParserVisitor<Result>): Result;
 }
 export declare class Double_string_template_atomContext extends ParserRuleContext {
-    DOUBLE_QUOTE_STRING_ATOM(): TerminalNode | undefined;
-    OPEN_BRACE(): TerminalNode | undefined;
-    TEMPLATE_CLOSE_BRACE(): TerminalNode | undefined;
-    test(): TestContext | undefined;
-    star_expr(): Star_exprContext | undefined;
-    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    constructor(parser?: Python3Parser, parent?: ParserRuleContext, invokingState?: number);
+    DOUBLE_QUOTE_STRING_ATOM(): TerminalNode;
+    OPEN_BRACE(): TerminalNode;
+    TEMPLATE_CLOSE_BRACE(): TerminalNode;
+    test(): TestContext;
+    star_expr(): Star_exprContext;
     get ruleIndex(): number;
     enterRule(listener: Python3ParserListener): void;
     exitRule(listener: Python3ParserListener): void;