java-ast/dist/parser/JavaParser.d.ts

Java Parser for JavaScript/TypeScript, based on antlr4ts

import { ATN } from "antlr4ts/atn/ATN";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { RuleContext } from "antlr4ts/RuleContext";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { JavaParserListener } from "./JavaParserListener";
import { JavaParserVisitor } from "./JavaParserVisitor";
export declare class JavaParser extends Parser {
    static readonly ABSTRACT = 1;
    static readonly ASSERT = 2;
    static readonly BOOLEAN = 3;
    static readonly BREAK = 4;
    static readonly BYTE = 5;
    static readonly CASE = 6;
    static readonly CATCH = 7;
    static readonly CHAR = 8;
    static readonly CLASS = 9;
    static readonly CONST = 10;
    static readonly CONTINUE = 11;
    static readonly DEFAULT = 12;
    static readonly DO = 13;
    static readonly DOUBLE = 14;
    static readonly ELSE = 15;
    static readonly ENUM = 16;
    static readonly EXTENDS = 17;
    static readonly FINAL = 18;
    static readonly FINALLY = 19;
    static readonly FLOAT = 20;
    static readonly FOR = 21;
    static readonly IF = 22;
    static readonly GOTO = 23;
    static readonly IMPLEMENTS = 24;
    static readonly IMPORT = 25;
    static readonly INSTANCEOF = 26;
    static readonly INT = 27;
    static readonly INTERFACE = 28;
    static readonly LONG = 29;
    static readonly NATIVE = 30;
    static readonly NEW = 31;
    static readonly PACKAGE = 32;
    static readonly PRIVATE = 33;
    static readonly PROTECTED = 34;
    static readonly PUBLIC = 35;
    static readonly RETURN = 36;
    static readonly SHORT = 37;
    static readonly STATIC = 38;
    static readonly STRICTFP = 39;
    static readonly SUPER = 40;
    static readonly SWITCH = 41;
    static readonly SYNCHRONIZED = 42;
    static readonly THIS = 43;
    static readonly THROW = 44;
    static readonly THROWS = 45;
    static readonly TRANSIENT = 46;
    static readonly TRY = 47;
    static readonly VOID = 48;
    static readonly VOLATILE = 49;
    static readonly WHILE = 50;
    static readonly MODULE = 51;
    static readonly OPEN = 52;
    static readonly REQUIRES = 53;
    static readonly EXPORTS = 54;
    static readonly OPENS = 55;
    static readonly TO = 56;
    static readonly USES = 57;
    static readonly PROVIDES = 58;
    static readonly WITH = 59;
    static readonly TRANSITIVE = 60;
    static readonly VAR = 61;
    static readonly YIELD = 62;
    static readonly RECORD = 63;
    static readonly SEALED = 64;
    static readonly PERMITS = 65;
    static readonly NON_SEALED = 66;
    static readonly DECIMAL_LITERAL = 67;
    static readonly HEX_LITERAL = 68;
    static readonly OCT_LITERAL = 69;
    static readonly BINARY_LITERAL = 70;
    static readonly FLOAT_LITERAL = 71;
    static readonly HEX_FLOAT_LITERAL = 72;
    static readonly BOOL_LITERAL = 73;
    static readonly CHAR_LITERAL = 74;
    static readonly STRING_LITERAL = 75;
    static readonly TEXT_BLOCK = 76;
    static readonly NULL_LITERAL = 77;
    static readonly LPAREN = 78;
    static readonly RPAREN = 79;
    static readonly LBRACE = 80;
    static readonly RBRACE = 81;
    static readonly LBRACK = 82;
    static readonly RBRACK = 83;
    static readonly SEMI = 84;
    static readonly COMMA = 85;
    static readonly DOT = 86;
    static readonly ASSIGN = 87;
    static readonly GT = 88;
    static readonly LT = 89;
    static readonly BANG = 90;
    static readonly TILDE = 91;
    static readonly QUESTION = 92;
    static readonly COLON = 93;
    static readonly EQUAL = 94;
    static readonly LE = 95;
    static readonly GE = 96;
    static readonly NOTEQUAL = 97;
    static readonly AND = 98;
    static readonly OR = 99;
    static readonly INC = 100;
    static readonly DEC = 101;
    static readonly ADD = 102;
    static readonly SUB = 103;
    static readonly MUL = 104;
    static readonly DIV = 105;
    static readonly BITAND = 106;
    static readonly BITOR = 107;
    static readonly CARET = 108;
    static readonly MOD = 109;
    static readonly ADD_ASSIGN = 110;
    static readonly SUB_ASSIGN = 111;
    static readonly MUL_ASSIGN = 112;
    static readonly DIV_ASSIGN = 113;
    static readonly AND_ASSIGN = 114;
    static readonly OR_ASSIGN = 115;
    static readonly XOR_ASSIGN = 116;
    static readonly MOD_ASSIGN = 117;
    static readonly LSHIFT_ASSIGN = 118;
    static readonly RSHIFT_ASSIGN = 119;
    static readonly URSHIFT_ASSIGN = 120;
    static readonly ARROW = 121;
    static readonly COLONCOLON = 122;
    static readonly AT = 123;
    static readonly ELLIPSIS = 124;
    static readonly WS = 125;
    static readonly COMMENT = 126;
    static readonly LINE_COMMENT = 127;
    static readonly IDENTIFIER = 128;
    static readonly RULE_compilationUnit = 0;
    static readonly RULE_packageDeclaration = 1;
    static readonly RULE_importDeclaration = 2;
    static readonly RULE_typeDeclaration = 3;
    static readonly RULE_modifier = 4;
    static readonly RULE_classOrInterfaceModifier = 5;
    static readonly RULE_variableModifier = 6;
    static readonly RULE_classDeclaration = 7;
    static readonly RULE_typeParameters = 8;
    static readonly RULE_typeParameter = 9;
    static readonly RULE_typeBound = 10;
    static readonly RULE_enumDeclaration = 11;
    static readonly RULE_enumConstants = 12;
    static readonly RULE_enumConstant = 13;
    static readonly RULE_enumBodyDeclarations = 14;
    static readonly RULE_interfaceDeclaration = 15;
    static readonly RULE_classBody = 16;
    static readonly RULE_interfaceBody = 17;
    static readonly RULE_classBodyDeclaration = 18;
    static readonly RULE_memberDeclaration = 19;
    static readonly RULE_methodDeclaration = 20;
    static readonly RULE_methodBody = 21;
    static readonly RULE_typeTypeOrVoid = 22;
    static readonly RULE_genericMethodDeclaration = 23;
    static readonly RULE_genericConstructorDeclaration = 24;
    static readonly RULE_constructorDeclaration = 25;
    static readonly RULE_compactConstructorDeclaration = 26;
    static readonly RULE_fieldDeclaration = 27;
    static readonly RULE_interfaceBodyDeclaration = 28;
    static readonly RULE_interfaceMemberDeclaration = 29;
    static readonly RULE_constDeclaration = 30;
    static readonly RULE_constantDeclarator = 31;
    static readonly RULE_interfaceMethodDeclaration = 32;
    static readonly RULE_interfaceMethodModifier = 33;
    static readonly RULE_genericInterfaceMethodDeclaration = 34;
    static readonly RULE_interfaceCommonBodyDeclaration = 35;
    static readonly RULE_variableDeclarators = 36;
    static readonly RULE_variableDeclarator = 37;
    static readonly RULE_variableDeclaratorId = 38;
    static readonly RULE_variableInitializer = 39;
    static readonly RULE_arrayInitializer = 40;
    static readonly RULE_classOrInterfaceType = 41;
    static readonly RULE_typeArgument = 42;
    static readonly RULE_qualifiedNameList = 43;
    static readonly RULE_formalParameters = 44;
    static readonly RULE_receiverParameter = 45;
    static readonly RULE_formalParameterList = 46;
    static readonly RULE_formalParameter = 47;
    static readonly RULE_lastFormalParameter = 48;
    static readonly RULE_lambdaLVTIList = 49;
    static readonly RULE_lambdaLVTIParameter = 50;
    static readonly RULE_qualifiedName = 51;
    static readonly RULE_literal = 52;
    static readonly RULE_integerLiteral = 53;
    static readonly RULE_floatLiteral = 54;
    static readonly RULE_altAnnotationQualifiedName = 55;
    static readonly RULE_annotation = 56;
    static readonly RULE_elementValuePairs = 57;
    static readonly RULE_elementValuePair = 58;
    static readonly RULE_elementValue = 59;
    static readonly RULE_elementValueArrayInitializer = 60;
    static readonly RULE_annotationTypeDeclaration = 61;
    static readonly RULE_annotationTypeBody = 62;
    static readonly RULE_annotationTypeElementDeclaration = 63;
    static readonly RULE_annotationTypeElementRest = 64;
    static readonly RULE_annotationMethodOrConstantRest = 65;
    static readonly RULE_annotationMethodRest = 66;
    static readonly RULE_annotationConstantRest = 67;
    static readonly RULE_defaultValue = 68;
    static readonly RULE_moduleDeclaration = 69;
    static readonly RULE_moduleBody = 70;
    static readonly RULE_moduleDirective = 71;
    static readonly RULE_requiresModifier = 72;
    static readonly RULE_recordDeclaration = 73;
    static readonly RULE_recordHeader = 74;
    static readonly RULE_recordComponentList = 75;
    static readonly RULE_recordComponent = 76;
    static readonly RULE_recordBody = 77;
    static readonly RULE_block = 78;
    static readonly RULE_blockStatement = 79;
    static readonly RULE_localVariableDeclaration = 80;
    static readonly RULE_identifier = 81;
    static readonly RULE_typeIdentifier = 82;
    static readonly RULE_localTypeDeclaration = 83;
    static readonly RULE_statement = 84;
    static readonly RULE_catchClause = 85;
    static readonly RULE_catchType = 86;
    static readonly RULE_finallyBlock = 87;
    static readonly RULE_resourceSpecification = 88;
    static readonly RULE_resources = 89;
    static readonly RULE_resource = 90;
    static readonly RULE_switchBlockStatementGroup = 91;
    static readonly RULE_switchLabel = 92;
    static readonly RULE_forControl = 93;
    static readonly RULE_forInit = 94;
    static readonly RULE_enhancedForControl = 95;
    static readonly RULE_parExpression = 96;
    static readonly RULE_expressionList = 97;
    static readonly RULE_methodCall = 98;
    static readonly RULE_expression = 99;
    static readonly RULE_pattern = 100;
    static readonly RULE_lambdaExpression = 101;
    static readonly RULE_lambdaParameters = 102;
    static readonly RULE_lambdaBody = 103;
    static readonly RULE_primary = 104;
    static readonly RULE_switchExpression = 105;
    static readonly RULE_switchLabeledRule = 106;
    static readonly RULE_guardedPattern = 107;
    static readonly RULE_switchRuleOutcome = 108;
    static readonly RULE_classType = 109;
    static readonly RULE_creator = 110;
    static readonly RULE_createdName = 111;
    static readonly RULE_innerCreator = 112;
    static readonly RULE_arrayCreatorRest = 113;
    static readonly RULE_classCreatorRest = 114;
    static readonly RULE_explicitGenericInvocation = 115;
    static readonly RULE_typeArgumentsOrDiamond = 116;
    static readonly RULE_nonWildcardTypeArgumentsOrDiamond = 117;
    static readonly RULE_nonWildcardTypeArguments = 118;
    static readonly RULE_typeList = 119;
    static readonly RULE_typeType = 120;
    static readonly RULE_primitiveType = 121;
    static readonly RULE_typeArguments = 122;
    static readonly RULE_superSuffix = 123;
    static readonly RULE_explicitGenericInvocationSuffix = 124;
    static readonly RULE_arguments = 125;
    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 ruleNames(): string[];
    get serializedATN(): string;
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    compilationUnit(): CompilationUnitContext;
    packageDeclaration(): PackageDeclarationContext;
    importDeclaration(): ImportDeclarationContext;
    typeDeclaration(): TypeDeclarationContext;
    modifier(): ModifierContext;
    classOrInterfaceModifier(): ClassOrInterfaceModifierContext;
    variableModifier(): VariableModifierContext;
    classDeclaration(): ClassDeclarationContext;
    typeParameters(): TypeParametersContext;
    typeParameter(): TypeParameterContext;
    typeBound(): TypeBoundContext;
    enumDeclaration(): EnumDeclarationContext;
    enumConstants(): EnumConstantsContext;
    enumConstant(): EnumConstantContext;
    enumBodyDeclarations(): EnumBodyDeclarationsContext;
    interfaceDeclaration(): InterfaceDeclarationContext;
    classBody(): ClassBodyContext;
    interfaceBody(): InterfaceBodyContext;
    classBodyDeclaration(): ClassBodyDeclarationContext;
    memberDeclaration(): MemberDeclarationContext;
    methodDeclaration(): MethodDeclarationContext;
    methodBody(): MethodBodyContext;
    typeTypeOrVoid(): TypeTypeOrVoidContext;
    genericMethodDeclaration(): GenericMethodDeclarationContext;
    genericConstructorDeclaration(): GenericConstructorDeclarationContext;
    constructorDeclaration(): ConstructorDeclarationContext;
    compactConstructorDeclaration(): CompactConstructorDeclarationContext;
    fieldDeclaration(): FieldDeclarationContext;
    interfaceBodyDeclaration(): InterfaceBodyDeclarationContext;
    interfaceMemberDeclaration(): InterfaceMemberDeclarationContext;
    constDeclaration(): ConstDeclarationContext;
    constantDeclarator(): ConstantDeclaratorContext;
    interfaceMethodDeclaration(): InterfaceMethodDeclarationContext;
    interfaceMethodModifier(): InterfaceMethodModifierContext;
    genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext;
    interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
    variableDeclarators(): VariableDeclaratorsContext;
    variableDeclarator(): VariableDeclaratorContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableInitializer(): VariableInitializerContext;
    arrayInitializer(): ArrayInitializerContext;
    classOrInterfaceType(): ClassOrInterfaceTypeContext;
    typeArgument(): TypeArgumentContext;
    qualifiedNameList(): QualifiedNameListContext;
    formalParameters(): FormalParametersContext;
    receiverParameter(): ReceiverParameterContext;
    formalParameterList(): FormalParameterListContext;
    formalParameter(): FormalParameterContext;
    lastFormalParameter(): LastFormalParameterContext;
    lambdaLVTIList(): LambdaLVTIListContext;
    lambdaLVTIParameter(): LambdaLVTIParameterContext;
    qualifiedName(): QualifiedNameContext;
    literal(): LiteralContext;
    integerLiteral(): IntegerLiteralContext;
    floatLiteral(): FloatLiteralContext;
    altAnnotationQualifiedName(): AltAnnotationQualifiedNameContext;
    annotation(): AnnotationContext;
    elementValuePairs(): ElementValuePairsContext;
    elementValuePair(): ElementValuePairContext;
    elementValue(): ElementValueContext;
    elementValueArrayInitializer(): ElementValueArrayInitializerContext;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext;
    annotationTypeBody(): AnnotationTypeBodyContext;
    annotationTypeElementDeclaration(): AnnotationTypeElementDeclarationContext;
    annotationTypeElementRest(): AnnotationTypeElementRestContext;
    annotationMethodOrConstantRest(): AnnotationMethodOrConstantRestContext;
    annotationMethodRest(): AnnotationMethodRestContext;
    annotationConstantRest(): AnnotationConstantRestContext;
    defaultValue(): DefaultValueContext;
    moduleDeclaration(): ModuleDeclarationContext;
    moduleBody(): ModuleBodyContext;
    moduleDirective(): ModuleDirectiveContext;
    requiresModifier(): RequiresModifierContext;
    recordDeclaration(): RecordDeclarationContext;
    recordHeader(): RecordHeaderContext;
    recordComponentList(): RecordComponentListContext;
    recordComponent(): RecordComponentContext;
    recordBody(): RecordBodyContext;
    block(): BlockContext;
    blockStatement(): BlockStatementContext;
    localVariableDeclaration(): LocalVariableDeclarationContext;
    identifier(): IdentifierContext;
    typeIdentifier(): TypeIdentifierContext;
    localTypeDeclaration(): LocalTypeDeclarationContext;
    statement(): StatementContext;
    catchClause(): CatchClauseContext;
    catchType(): CatchTypeContext;
    finallyBlock(): FinallyBlockContext;
    resourceSpecification(): ResourceSpecificationContext;
    resources(): ResourcesContext;
    resource(): ResourceContext;
    switchBlockStatementGroup(): SwitchBlockStatementGroupContext;
    switchLabel(): SwitchLabelContext;
    forControl(): ForControlContext;
    forInit(): ForInitContext;
    enhancedForControl(): EnhancedForControlContext;
    parExpression(): ParExpressionContext;
    expressionList(): ExpressionListContext;
    methodCall(): MethodCallContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    pattern(): PatternContext;
    lambdaExpression(): LambdaExpressionContext;
    lambdaParameters(): LambdaParametersContext;
    lambdaBody(): LambdaBodyContext;
    primary(): PrimaryContext;
    switchExpression(): SwitchExpressionContext;
    switchLabeledRule(): SwitchLabeledRuleContext;
    guardedPattern(): GuardedPatternContext;
    guardedPattern(_p: number): GuardedPatternContext;
    switchRuleOutcome(): SwitchRuleOutcomeContext;
    classType(): ClassTypeContext;
    creator(): CreatorContext;
    createdName(): CreatedNameContext;
    innerCreator(): InnerCreatorContext;
    arrayCreatorRest(): ArrayCreatorRestContext;
    classCreatorRest(): ClassCreatorRestContext;
    explicitGenericInvocation(): ExplicitGenericInvocationContext;
    typeArgumentsOrDiamond(): TypeArgumentsOrDiamondContext;
    nonWildcardTypeArgumentsOrDiamond(): NonWildcardTypeArgumentsOrDiamondContext;
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext;
    typeList(): TypeListContext;
    typeType(): TypeTypeContext;
    primitiveType(): PrimitiveTypeContext;
    typeArguments(): TypeArgumentsContext;
    superSuffix(): SuperSuffixContext;
    explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext;
    arguments(): ArgumentsContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    private guardedPattern_sempred;
    private static readonly _serializedATNSegments;
    private static readonly _serializedATNSegment0;
    private static readonly _serializedATNSegment1;
    private static readonly _serializedATNSegment2;
    private static readonly _serializedATNSegment3;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class CompilationUnitContext extends ParserRuleContext {
    packageDeclaration(): PackageDeclarationContext | undefined;
    importDeclaration(): ImportDeclarationContext[];
    importDeclaration(i: number): ImportDeclarationContext;
    SEMI(): TerminalNode[];
    SEMI(i: number): TerminalNode;
    typeDeclaration(): TypeDeclarationContext[];
    typeDeclaration(i: number): TypeDeclarationContext;
    moduleDeclaration(): ModuleDeclarationContext | undefined;
    EOF(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class PackageDeclarationContext extends ParserRuleContext {
    PACKAGE(): TerminalNode;
    qualifiedName(): QualifiedNameContext;
    SEMI(): TerminalNode;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ImportDeclarationContext extends ParserRuleContext {
    IMPORT(): TerminalNode;
    qualifiedName(): QualifiedNameContext;
    SEMI(): TerminalNode;
    STATIC(): TerminalNode | undefined;
    DOT(): TerminalNode | undefined;
    MUL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeDeclarationContext extends ParserRuleContext {
    classDeclaration(): ClassDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    recordDeclaration(): RecordDeclarationContext | undefined;
    classOrInterfaceModifier(): ClassOrInterfaceModifierContext[];
    classOrInterfaceModifier(i: number): ClassOrInterfaceModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ModifierContext extends ParserRuleContext {
    classOrInterfaceModifier(): ClassOrInterfaceModifierContext | undefined;
    NATIVE(): TerminalNode | undefined;
    SYNCHRONIZED(): TerminalNode | undefined;
    TRANSIENT(): TerminalNode | undefined;
    VOLATILE(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ClassOrInterfaceModifierContext extends ParserRuleContext {
    annotation(): AnnotationContext | undefined;
    PUBLIC(): TerminalNode | undefined;
    PROTECTED(): TerminalNode | undefined;
    PRIVATE(): TerminalNode | undefined;
    STATIC(): TerminalNode | undefined;
    ABSTRACT(): TerminalNode | undefined;
    FINAL(): TerminalNode | undefined;
    STRICTFP(): TerminalNode | undefined;
    SEALED(): TerminalNode | undefined;
    NON_SEALED(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class VariableModifierContext extends ParserRuleContext {
    FINAL(): TerminalNode | undefined;
    annotation(): AnnotationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ClassDeclarationContext extends ParserRuleContext {
    CLASS(): TerminalNode;
    identifier(): IdentifierContext;
    classBody(): ClassBodyContext;
    typeParameters(): TypeParametersContext | undefined;
    EXTENDS(): TerminalNode | undefined;
    typeType(): TypeTypeContext | undefined;
    IMPLEMENTS(): TerminalNode | undefined;
    typeList(): TypeListContext[];
    typeList(i: number): TypeListContext;
    PERMITS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeParametersContext extends ParserRuleContext {
    LT(): TerminalNode;
    typeParameter(): TypeParameterContext[];
    typeParameter(i: number): TypeParameterContext;
    GT(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeParameterContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    EXTENDS(): TerminalNode | undefined;
    typeBound(): TypeBoundContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeBoundContext extends ParserRuleContext {
    typeType(): TypeTypeContext[];
    typeType(i: number): TypeTypeContext;
    BITAND(): TerminalNode[];
    BITAND(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class EnumDeclarationContext extends ParserRuleContext {
    ENUM(): TerminalNode;
    identifier(): IdentifierContext;
    LBRACE(): TerminalNode;
    RBRACE(): TerminalNode;
    IMPLEMENTS(): TerminalNode | undefined;
    typeList(): TypeListContext | undefined;
    enumConstants(): EnumConstantsContext | undefined;
    COMMA(): TerminalNode | undefined;
    enumBodyDeclarations(): EnumBodyDeclarationsContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class EnumConstantsContext extends ParserRuleContext {
    enumConstant(): EnumConstantContext[];
    enumConstant(i: number): EnumConstantContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class EnumConstantContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    arguments(): ArgumentsContext | undefined;
    classBody(): ClassBodyContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class EnumBodyDeclarationsContext extends ParserRuleContext {
    SEMI(): TerminalNode;
    classBodyDeclaration(): ClassBodyDeclarationContext[];
    classBodyDeclaration(i: number): ClassBodyDeclarationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceDeclarationContext extends ParserRuleContext {
    INTERFACE(): TerminalNode;
    identifier(): IdentifierContext;
    interfaceBody(): InterfaceBodyContext;
    typeParameters(): TypeParametersContext | undefined;
    EXTENDS(): TerminalNode | undefined;
    typeList(): TypeListContext[];
    typeList(i: number): TypeListContext;
    PERMITS(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ClassBodyContext extends ParserRuleContext {
    LBRACE(): TerminalNode;
    RBRACE(): TerminalNode;
    classBodyDeclaration(): ClassBodyDeclarationContext[];
    classBodyDeclaration(i: number): ClassBodyDeclarationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceBodyContext extends ParserRuleContext {
    LBRACE(): TerminalNode;
    RBRACE(): TerminalNode;
    interfaceBodyDeclaration(): InterfaceBodyDeclarationContext[];
    interfaceBodyDeclaration(i: number): InterfaceBodyDeclarationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ClassBodyDeclarationContext extends ParserRuleContext {
    SEMI(): TerminalNode | undefined;
    block(): BlockContext | undefined;
    STATIC(): TerminalNode | undefined;
    memberDeclaration(): MemberDeclarationContext | undefined;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class MemberDeclarationContext extends ParserRuleContext {
    recordDeclaration(): RecordDeclarationContext | undefined;
    methodDeclaration(): MethodDeclarationContext | undefined;
    genericMethodDeclaration(): GenericMethodDeclarationContext | undefined;
    fieldDeclaration(): FieldDeclarationContext | undefined;
    constructorDeclaration(): ConstructorDeclarationContext | undefined;
    genericConstructorDeclaration(): GenericConstructorDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    classDeclaration(): ClassDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class MethodDeclarationContext extends ParserRuleContext {
    typeTypeOrVoid(): TypeTypeOrVoidContext;
    identifier(): IdentifierContext;
    formalParameters(): FormalParametersContext;
    methodBody(): MethodBodyContext;
    LBRACK(): TerminalNode[];
    LBRACK(i: number): TerminalNode;
    RBRACK(): TerminalNode[];
    RBRACK(i: number): TerminalNode;
    THROWS(): TerminalNode | undefined;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class MethodBodyContext extends ParserRuleContext {
    block(): BlockContext | undefined;
    SEMI(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeTypeOrVoidContext extends ParserRuleContext {
    typeType(): TypeTypeContext | undefined;
    VOID(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class GenericMethodDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    methodDeclaration(): MethodDeclarationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class GenericConstructorDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    constructorDeclaration(): ConstructorDeclarationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ConstructorDeclarationContext extends ParserRuleContext {
    _constructorBody: BlockContext;
    identifier(): IdentifierContext;
    formalParameters(): FormalParametersContext;
    block(): BlockContext;
    THROWS(): TerminalNode | undefined;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class CompactConstructorDeclarationContext extends ParserRuleContext {
    _constructorBody: BlockContext;
    identifier(): IdentifierContext;
    block(): BlockContext;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class FieldDeclarationContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclarators(): VariableDeclaratorsContext;
    SEMI(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceBodyDeclarationContext extends ParserRuleContext {
    interfaceMemberDeclaration(): InterfaceMemberDeclarationContext | undefined;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    SEMI(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceMemberDeclarationContext extends ParserRuleContext {
    recordDeclaration(): RecordDeclarationContext | undefined;
    constDeclaration(): ConstDeclarationContext | undefined;
    interfaceMethodDeclaration(): InterfaceMethodDeclarationContext | undefined;
    genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    classDeclaration(): ClassDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ConstDeclarationContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    constantDeclarator(): ConstantDeclaratorContext[];
    constantDeclarator(i: number): ConstantDeclaratorContext;
    SEMI(): TerminalNode;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ConstantDeclaratorContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    ASSIGN(): TerminalNode;
    variableInitializer(): VariableInitializerContext;
    LBRACK(): TerminalNode[];
    LBRACK(i: number): TerminalNode;
    RBRACK(): TerminalNode[];
    RBRACK(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceMethodDeclarationContext extends ParserRuleContext {
    interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
    interfaceMethodModifier(): InterfaceMethodModifierContext[];
    interfaceMethodModifier(i: number): InterfaceMethodModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceMethodModifierContext extends ParserRuleContext {
    annotation(): AnnotationContext | undefined;
    PUBLIC(): TerminalNode | undefined;
    ABSTRACT(): TerminalNode | undefined;
    DEFAULT(): TerminalNode | undefined;
    STATIC(): TerminalNode | undefined;
    STRICTFP(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    interfaceCommonBodyDeclaration(): InterfaceCommonBodyDeclarationContext;
    interfaceMethodModifier(): InterfaceMethodModifierContext[];
    interfaceMethodModifier(i: number): InterfaceMethodModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class InterfaceCommonBodyDeclarationContext extends ParserRuleContext {
    typeTypeOrVoid(): TypeTypeOrVoidContext;
    identifier(): IdentifierContext;
    formalParameters(): FormalParametersContext;
    methodBody(): MethodBodyContext;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    LBRACK(): TerminalNode[];
    LBRACK(i: number): TerminalNode;
    RBRACK(): TerminalNode[];
    RBRACK(i: number): TerminalNode;
    THROWS(): TerminalNode | undefined;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class VariableDeclaratorsContext extends ParserRuleContext {
    variableDeclarator(): VariableDeclaratorContext[];
    variableDeclarator(i: number): VariableDeclaratorContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class VariableDeclaratorContext extends ParserRuleContext {
    variableDeclaratorId(): VariableDeclaratorIdContext;
    ASSIGN(): TerminalNode | undefined;
    variableInitializer(): VariableInitializerContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class VariableDeclaratorIdContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    LBRACK(): TerminalNode[];
    LBRACK(i: number): TerminalNode;
    RBRACK(): TerminalNode[];
    RBRACK(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class VariableInitializerContext extends ParserRuleContext {
    arrayInitializer(): ArrayInitializerContext | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ArrayInitializerContext extends ParserRuleContext {
    LBRACE(): TerminalNode;
    RBRACE(): TerminalNode;
    variableInitializer(): VariableInitializerContext[];
    variableInitializer(i: number): VariableInitializerContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ClassOrInterfaceTypeContext extends ParserRuleContext {
    typeIdentifier(): TypeIdentifierContext;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOT(): TerminalNode[];
    DOT(i: number): TerminalNode;
    typeArguments(): TypeArgumentsContext[];
    typeArguments(i: number): TypeArgumentsContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class TypeArgumentContext extends ParserRuleContext {
    typeType(): TypeTypeContext | undefined;
    QUESTION(): TerminalNode | undefined;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    EXTENDS(): TerminalNode | undefined;
    SUPER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class QualifiedNameListContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext[];
    qualifiedName(i: number): QualifiedNameContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class FormalParametersContext extends ParserRuleContext {
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    receiverParameter(): ReceiverParameterContext | undefined;
    COMMA(): TerminalNode | undefined;
    formalParameterList(): FormalParameterListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class ReceiverParameterContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    THIS(): TerminalNode;
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOT(): TerminalNode[];
    DOT(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class FormalParameterListContext extends ParserRuleContext {
    formalParameter(): FormalParameterContext[];
    formalParameter(i: number): FormalParameterContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    lastFormalParameter(): LastFormalParameterContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class FormalParameterContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class LastFormalParameterContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    ELLIPSIS(): TerminalNode;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class LambdaLVTIListContext extends ParserRuleContext {
    lambdaLVTIParameter(): LambdaLVTIParameterContext[];
    lambdaLVTIParameter(i: number): LambdaLVTIParameterContext;
    COMMA(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class LambdaLVTIParameterContext extends ParserRuleContext {
    VAR(): TerminalNode;
    identifier(): IdentifierContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class QualifiedNameContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    DOT(): TerminalNode[];
    DOT(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    integerLiteral(): IntegerLiteralContext | undefined;
    floatLiteral(): FloatLiteralContext | undefined;
    CHAR_LITERAL(): TerminalNode | undefined;
    STRING_LITERAL(): TerminalNode | undefined;
    BOOL_LITERAL(): TerminalNode | undefined;
    NULL_LITERAL(): TerminalNode | undefined;
    TEXT_BLOCK(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: JavaParserListener): void;
    exitRule(listener: JavaParserListener): void;
    accept<Result>(visitor: JavaParserVisitor<Result>): Result;
}
export declare class IntegerLiteralContext extends ParserRuleContext {
    DECIMAL_LITERAL(): Te