import { ATN } from "antlr4ts/atn/ATN";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { RuleContext } from "antlr4ts/RuleContext";
import { TokenStream } from "antlr4ts/TokenStream";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { JavaListener } from "./JavaListener";
import { JavaVisitor } from "./JavaVisitor";
export declare class EnumConstantNameContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class CompilationUnitContext extends ParserRuleContext {
    EOF(): TerminalNode;
    packageDeclaration(): PackageDeclarationContext | undefined;
    importDeclaration(): ImportDeclarationContext[];
    importDeclaration(i: number): ImportDeclarationContext;
    typeDeclaration(): TypeDeclarationContext[];
    typeDeclaration(i: number): TypeDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class PackageDeclarationContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ImportDeclarationContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeDeclarationContext extends ParserRuleContext {
    classDeclaration(): ClassDeclarationContext | undefined;
    classOrInterfaceModifier(): ClassOrInterfaceModifierContext[];
    classOrInterfaceModifier(i: number): ClassOrInterfaceModifierContext;
    enumDeclaration(): EnumDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ModifierContext extends ParserRuleContext {
    classOrInterfaceModifier(): ClassOrInterfaceModifierContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassOrInterfaceModifierContext extends ParserRuleContext {
    annotation(): AnnotationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class VariableModifierContext extends ParserRuleContext {
    annotation(): AnnotationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    classBody(): ClassBodyContext;
    typeParameters(): TypeParametersContext | undefined;
    typeType(): TypeTypeContext | undefined;
    typeList(): TypeListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeParametersContext extends ParserRuleContext {
    typeParameter(): TypeParameterContext[];
    typeParameter(i: number): TypeParameterContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeParameterContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    typeBound(): TypeBoundContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeBoundContext extends ParserRuleContext {
    typeType(): TypeTypeContext[];
    typeType(i: number): TypeTypeContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class EnumDeclarationContext extends ParserRuleContext {
    ENUM(): TerminalNode;
    Identifier(): TerminalNode;
    typeList(): TypeListContext | undefined;
    enumConstants(): EnumConstantsContext | undefined;
    enumBodyDeclarations(): EnumBodyDeclarationsContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class EnumConstantsContext extends ParserRuleContext {
    enumConstant(): EnumConstantContext[];
    enumConstant(i: number): EnumConstantContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class EnumConstantContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    annotation(): AnnotationContext[];
    annotation(i: number): AnnotationContext;
    arguments(): ArgumentsContext | undefined;
    classBody(): ClassBodyContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class EnumBodyDeclarationsContext extends ParserRuleContext {
    classBodyDeclaration(): ClassBodyDeclarationContext[];
    classBodyDeclaration(i: number): ClassBodyDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InterfaceDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    interfaceBody(): InterfaceBodyContext;
    typeParameters(): TypeParametersContext | undefined;
    typeList(): TypeListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeListContext extends ParserRuleContext {
    typeType(): TypeTypeContext[];
    typeType(i: number): TypeTypeContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassBodyContext extends ParserRuleContext {
    classBodyDeclaration(): ClassBodyDeclarationContext[];
    classBodyDeclaration(i: number): ClassBodyDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InterfaceBodyContext extends ParserRuleContext {
    interfaceBodyDeclaration(): InterfaceBodyDeclarationContext[];
    interfaceBodyDeclaration(i: number): InterfaceBodyDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassBodyDeclarationContext extends ParserRuleContext {
    block(): BlockContext | undefined;
    memberDeclaration(): MemberDeclarationContext | undefined;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class MemberDeclarationContext extends ParserRuleContext {
    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, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class MethodDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    formalParameters(): FormalParametersContext;
    typeType(): TypeTypeContext | undefined;
    methodBody(): MethodBodyContext | undefined;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class GenericMethodDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    methodDeclaration(): MethodDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ConstructorDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    formalParameters(): FormalParametersContext;
    constructorBody(): ConstructorBodyContext;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class GenericConstructorDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    constructorDeclaration(): ConstructorDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class FieldDeclarationContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclarators(): VariableDeclaratorsContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InterfaceBodyDeclarationContext extends ParserRuleContext {
    interfaceMemberDeclaration(): InterfaceMemberDeclarationContext | undefined;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InterfaceMemberDeclarationContext extends ParserRuleContext {
    constDeclaration(): ConstDeclarationContext | undefined;
    interfaceMethodDeclaration(): InterfaceMethodDeclarationContext | undefined;
    genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    classDeclaration(): ClassDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ConstDeclarationContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    constantDeclarator(): ConstantDeclaratorContext[];
    constantDeclarator(i: number): ConstantDeclaratorContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ConstantDeclaratorContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    variableInitializer(): VariableInitializerContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InterfaceMethodDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    formalParameters(): FormalParametersContext;
    typeType(): TypeTypeContext | undefined;
    qualifiedNameList(): QualifiedNameListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
    typeParameters(): TypeParametersContext;
    interfaceMethodDeclaration(): InterfaceMethodDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class VariableDeclaratorsContext extends ParserRuleContext {
    variableDeclarator(): VariableDeclaratorContext[];
    variableDeclarator(i: number): VariableDeclaratorContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class VariableDeclaratorContext extends ParserRuleContext {
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableInitializer(): VariableInitializerContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class VariableDeclaratorIdContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class VariableInitializerContext extends ParserRuleContext {
    arrayInitializer(): ArrayInitializerContext | undefined;
    expression(): ExpressionContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ArrayInitializerContext extends ParserRuleContext {
    variableInitializer(): VariableInitializerContext[];
    variableInitializer(i: number): VariableInitializerContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeTypeContext extends ParserRuleContext {
    classOrInterfaceType(): ClassOrInterfaceTypeContext | undefined;
    primitiveType(): PrimitiveTypeContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassOrInterfaceTypeContext extends ParserRuleContext {
    Identifier(): TerminalNode[];
    Identifier(i: number): TerminalNode;
    typeArguments(): TypeArgumentsContext[];
    typeArguments(i: number): TypeArgumentsContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class PrimitiveTypeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeArgumentsContext extends ParserRuleContext {
    typeArgument(): TypeArgumentContext[];
    typeArgument(i: number): TypeArgumentContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeArgumentContext extends ParserRuleContext {
    typeType(): TypeTypeContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class QualifiedNameListContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext[];
    qualifiedName(i: number): QualifiedNameContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class FormalParametersContext extends ParserRuleContext {
    formalParameterList(): FormalParameterListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class FormalParameterListContext extends ParserRuleContext {
    formalParameter(): FormalParameterContext[];
    formalParameter(i: number): FormalParameterContext;
    lastFormalParameter(): LastFormalParameterContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class FormalParameterContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class LastFormalParameterContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class MethodBodyContext extends ParserRuleContext {
    block(): BlockContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ConstructorBodyContext extends ParserRuleContext {
    block(): BlockContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class QualifiedNameContext extends ParserRuleContext {
    Identifier(): TerminalNode[];
    Identifier(i: number): TerminalNode;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    IntegerLiteral(): TerminalNode | undefined;
    FloatingPointLiteral(): TerminalNode | undefined;
    CharacterLiteral(): TerminalNode | undefined;
    StringLiteral(): TerminalNode | undefined;
    BooleanLiteral(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationContext extends ParserRuleContext {
    annotationName(): AnnotationNameContext;
    elementValuePairs(): ElementValuePairsContext | undefined;
    elementValue(): ElementValueContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationNameContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ElementValuePairsContext extends ParserRuleContext {
    elementValuePair(): ElementValuePairContext[];
    elementValuePair(i: number): ElementValuePairContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ElementValuePairContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    elementValue(): ElementValueContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ElementValueContext extends ParserRuleContext {
    expression(): ExpressionContext | undefined;
    annotation(): AnnotationContext | undefined;
    elementValueArrayInitializer(): ElementValueArrayInitializerContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ElementValueArrayInitializerContext extends ParserRuleContext {
    elementValue(): ElementValueContext[];
    elementValue(i: number): ElementValueContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationTypeDeclarationContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    annotationTypeBody(): AnnotationTypeBodyContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationTypeBodyContext extends ParserRuleContext {
    annotationTypeElementDeclaration(): AnnotationTypeElementDeclarationContext[];
    annotationTypeElementDeclaration(i: number): AnnotationTypeElementDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
    annotationTypeElementRest(): AnnotationTypeElementRestContext | undefined;
    modifier(): ModifierContext[];
    modifier(i: number): ModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationTypeElementRestContext extends ParserRuleContext {
    typeType(): TypeTypeContext | undefined;
    annotationMethodOrConstantRest(): AnnotationMethodOrConstantRestContext | undefined;
    classDeclaration(): ClassDeclarationContext | undefined;
    interfaceDeclaration(): InterfaceDeclarationContext | undefined;
    enumDeclaration(): EnumDeclarationContext | undefined;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationMethodOrConstantRestContext extends ParserRuleContext {
    annotationMethodRest(): AnnotationMethodRestContext | undefined;
    annotationConstantRest(): AnnotationConstantRestContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationMethodRestContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    defaultValue(): DefaultValueContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class AnnotationConstantRestContext extends ParserRuleContext {
    variableDeclarators(): VariableDeclaratorsContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class DefaultValueContext extends ParserRuleContext {
    elementValue(): ElementValueContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class BlockContext extends ParserRuleContext {
    blockStatement(): BlockStatementContext[];
    blockStatement(i: number): BlockStatementContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class BlockStatementContext extends ParserRuleContext {
    localVariableDeclarationStatement(): LocalVariableDeclarationStatementContext | undefined;
    statement(): StatementContext | undefined;
    typeDeclaration(): TypeDeclarationContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class LocalVariableDeclarationStatementContext extends ParserRuleContext {
    localVariableDeclaration(): LocalVariableDeclarationContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class LocalVariableDeclarationContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclarators(): VariableDeclaratorsContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class StatementContext extends ParserRuleContext {
    block(): BlockContext | undefined;
    ASSERT(): TerminalNode | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    parExpression(): ParExpressionContext | undefined;
    statement(): StatementContext[];
    statement(i: number): StatementContext;
    forControl(): ForControlContext | undefined;
    finallyBlock(): FinallyBlockContext | undefined;
    catchClause(): CatchClauseContext[];
    catchClause(i: number): CatchClauseContext;
    resourceSpecification(): ResourceSpecificationContext | undefined;
    switchBlockStatementGroup(): SwitchBlockStatementGroupContext[];
    switchBlockStatementGroup(i: number): SwitchBlockStatementGroupContext;
    switchLabel(): SwitchLabelContext[];
    switchLabel(i: number): SwitchLabelContext;
    Identifier(): TerminalNode | undefined;
    statementExpression(): StatementExpressionContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class CatchClauseContext extends ParserRuleContext {
    catchType(): CatchTypeContext;
    Identifier(): TerminalNode;
    block(): BlockContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class CatchTypeContext extends ParserRuleContext {
    qualifiedName(): QualifiedNameContext[];
    qualifiedName(i: number): QualifiedNameContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class FinallyBlockContext extends ParserRuleContext {
    block(): BlockContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ResourceSpecificationContext extends ParserRuleContext {
    resources(): ResourcesContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ResourcesContext extends ParserRuleContext {
    resource(): ResourceContext[];
    resource(i: number): ResourceContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ResourceContext extends ParserRuleContext {
    classOrInterfaceType(): ClassOrInterfaceTypeContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    expression(): ExpressionContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class SwitchBlockStatementGroupContext extends ParserRuleContext {
    switchLabel(): SwitchLabelContext[];
    switchLabel(i: number): SwitchLabelContext;
    blockStatement(): BlockStatementContext[];
    blockStatement(i: number): BlockStatementContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class SwitchLabelContext extends ParserRuleContext {
    constantExpression(): ConstantExpressionContext | undefined;
    enumConstantName(): EnumConstantNameContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ForControlContext extends ParserRuleContext {
    enhancedForControl(): EnhancedForControlContext | undefined;
    forInit(): ForInitContext | undefined;
    expression(): ExpressionContext | undefined;
    forUpdate(): ForUpdateContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ForInitContext extends ParserRuleContext {
    localVariableDeclaration(): LocalVariableDeclarationContext | undefined;
    expressionList(): ExpressionListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class EnhancedForControlContext extends ParserRuleContext {
    typeType(): TypeTypeContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    expression(): ExpressionContext;
    variableModifier(): VariableModifierContext[];
    variableModifier(i: number): VariableModifierContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ForUpdateContext extends ParserRuleContext {
    expressionList(): ExpressionListContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ParExpressionContext extends ParserRuleContext {
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ExpressionListContext extends ParserRuleContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class StatementExpressionContext extends ParserRuleContext {
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ConstantExpressionContext extends ParserRuleContext {
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    primary(): PrimaryContext | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    Identifier(): TerminalNode | undefined;
    innerCreator(): InnerCreatorContext | undefined;
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
    superSuffix(): SuperSuffixContext | undefined;
    explicitGenericInvocation(): ExplicitGenericInvocationContext | undefined;
    expressionList(): ExpressionListContext | undefined;
    creator(): CreatorContext | undefined;
    typeType(): TypeTypeContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class PrimaryContext extends ParserRuleContext {
    expression(): ExpressionContext | undefined;
    literal(): LiteralContext | undefined;
    Identifier(): TerminalNode | undefined;
    typeType(): TypeTypeContext | undefined;
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
    explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext | undefined;
    arguments(): ArgumentsContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class CreatorContext extends ParserRuleContext {
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
    createdName(): CreatedNameContext;
    classCreatorRest(): ClassCreatorRestContext | undefined;
    arrayCreatorRest(): ArrayCreatorRestContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class CreatedNameContext extends ParserRuleContext {
    Identifier(): TerminalNode[];
    Identifier(i: number): TerminalNode;
    typeArgumentsOrDiamond(): TypeArgumentsOrDiamondContext[];
    typeArgumentsOrDiamond(i: number): TypeArgumentsOrDiamondContext;
    primitiveType(): PrimitiveTypeContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class InnerCreatorContext extends ParserRuleContext {
    Identifier(): TerminalNode;
    classCreatorRest(): ClassCreatorRestContext;
    nonWildcardTypeArgumentsOrDiamond(): NonWildcardTypeArgumentsOrDiamondContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ArrayCreatorRestContext extends ParserRuleContext {
    arrayInitializer(): ArrayInitializerContext | undefined;
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ClassCreatorRestContext extends ParserRuleContext {
    arguments(): ArgumentsContext;
    classBody(): ClassBodyContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ExplicitGenericInvocationContext extends ParserRuleContext {
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext;
    explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class NonWildcardTypeArgumentsContext extends ParserRuleContext {
    typeList(): TypeListContext;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class TypeArgumentsOrDiamondContext extends ParserRuleContext {
    typeArguments(): TypeArgumentsContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext {
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class SuperSuffixContext extends ParserRuleContext {
    arguments(): ArgumentsContext | undefined;
    Identifier(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ExplicitGenericInvocationSuffixContext extends ParserRuleContext {
    superSuffix(): SuperSuffixContext | undefined;
    Identifier(): TerminalNode | undefined;
    arguments(): ArgumentsContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
export declare class ArgumentsContext extends ParserRuleContext {
    expressionList(): ExpressionListContext | undefined;
    constructor(parent: ParserRuleContext, invokingState: number);
    readonly ruleIndex: number;
    enterRule(listener: JavaListener): void;
    exitRule(listener: JavaListener): void;
    accept<Result>(visitor: JavaVisitor<Result>): Result;
}
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 IntegerLiteral = 51;
    static readonly FloatingPointLiteral = 52;
    static readonly BooleanLiteral = 53;
    static readonly CharacterLiteral = 54;
    static readonly StringLiteral = 55;
    static readonly NullLiteral = 56;
    static readonly LPAREN = 57;
    static readonly RPAREN = 58;
    static readonly LBRACE = 59;
    static readonly RBRACE = 60;
    static readonly LBRACK = 61;
    static readonly RBRACK = 62;
    static readonly SEMI = 63;
    static readonly COMMA = 64;
    static readonly DOT = 65;
    static readonly ASSIGN = 66;
    static readonly GT = 67;
    static readonly LT = 68;
    static readonly BANG = 69;
    static readonly TILDE = 70;
    static readonly QUESTION = 71;
    static readonly COLON = 72;
    static readonly EQUAL = 73;
    static readonly LE = 74;
    static readonly GE = 75;
    static readonly NOTEQUAL = 76;
    static readonly AND = 77;
    static readonly OR = 78;
    static readonly INC = 79;
    static readonly DEC = 80;
    static readonly ADD = 81;
    static readonly SUB = 82;
    static readonly MUL = 83;
    static readonly DIV = 84;
    static readonly BITAND = 85;
    static readonly BITOR = 86;
    static readonly CARET = 87;
    static readonly MOD = 88;
    static readonly ADD_ASSIGN = 89;
    static readonly SUB_ASSIGN = 90;
    static readonly MUL_ASSIGN = 91;
    static readonly DIV_ASSIGN = 92;
    static readonly AND_ASSIGN = 93;
    static readonly OR_ASSIGN = 94;
    static readonly XOR_ASSIGN = 95;
    static readonly MOD_ASSIGN = 96;
    static readonly LSHIFT_ASSIGN = 97;
    static readonly RSHIFT_ASSIGN = 98;
    static readonly URSHIFT_ASSIGN = 99;
    static readonly Identifier = 100;
    static readonly AT = 101;
    static readonly ELLIPSIS = 102;
    static readonly WS = 103;
    static readonly COMMENT = 104;
    static readonly LINE_COMMENT = 105;
    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_typeList = 16;
    static readonly RULE_classBody = 17;
    static readonly RULE_interfaceBody = 18;
    static readonly RULE_classBodyDeclaration = 19;
    static readonly RULE_memberDeclaration = 20;
    static readonly RULE_methodDeclaration = 21;
    static readonly RULE_genericMethodDeclaration = 22;
    static readonly RULE_constructorDeclaration = 23;
    static readonly RULE_genericConstructorDeclaration = 24;
    static readonly RULE_fieldDeclaration = 25;
    static readonly RULE_interfaceBodyDeclaration = 26;
    static readonly RULE_interfaceMemberDeclaration = 27;
    static readonly RULE_constDeclaration = 28;
    static readonly RULE_constantDeclarator = 29;
    static readonly RULE_interfaceMethodDeclaration = 30;
    static readonly RULE_genericInterfaceMethodDeclaration = 31;
    static readonly RULE_variableDeclarators = 32;
    static readonly RULE_variableDeclarator = 33;
    static readonly RULE_variableDeclaratorId = 34;
    static readonly RULE_variableInitializer = 35;
    static readonly RULE_arrayInitializer = 36;
    static readonly RULE_enumConstantName = 37;
    static readonly RULE_typeType = 38;
    static readonly RULE_classOrInterfaceType = 39;
    static readonly RULE_primitiveType = 40;
    static readonly RULE_typeArguments = 41;
    static readonly RULE_typeArgument = 42;
    static readonly RULE_qualifiedNameList = 43;
    static readonly RULE_formalParameters = 44;
    static readonly RULE_formalParameterList = 45;
    static readonly RULE_formalParameter = 46;
    static readonly RULE_lastFormalParameter = 47;
    static readonly RULE_methodBody = 48;
    static readonly RULE_constructorBody = 49;
    static readonly RULE_qualifiedName = 50;
    static readonly RULE_literal = 51;
    static readonly RULE_annotation = 52;
    static readonly RULE_annotationName = 53;
    static readonly RULE_elementValuePairs = 54;
    static readonly RULE_elementValuePair = 55;
    static readonly RULE_elementValue = 56;
    static readonly RULE_elementValueArrayInitializer = 57;
    static readonly RULE_annotationTypeDeclaration = 58;
    static readonly RULE_annotationTypeBody = 59;
    static readonly RULE_annotationTypeElementDeclaration = 60;
    static readonly RULE_annotationTypeElementRest = 61;
    static readonly RULE_annotationMethodOrConstantRest = 62;
    static readonly RULE_annotationMethodRest = 63;
    static readonly RULE_annotationConstantRest = 64;
    static readonly RULE_defaultValue = 65;
    static readonly RULE_block = 66;
    static readonly RULE_blockStatement = 67;
    static readonly RULE_localVariableDeclarationStatement = 68;
    static readonly RULE_localVariableDeclaration = 69;
    static readonly RULE_statement = 70;
    static readonly RULE_catchClause = 71;
    static readonly RULE_catchType = 72;
    static readonly RULE_finallyBlock = 73;
    static readonly RULE_resourceSpecification = 74;
    static readonly RULE_resources = 75;
    static readonly RULE_resource = 76;
    static readonly RULE_switchBlockStatementGroup = 77;
    static readonly RULE_switchLabel = 78;
    static readonly RULE_forControl = 79;
    static readonly RULE_forInit = 80;
    static readonly RULE_enhancedForControl = 81;
    static readonly RULE_forUpdate = 82;
    static readonly RULE_parExpression = 83;
    static readonly RULE_expressionList = 84;
    static readonly RULE_statementExpression = 85;
    static readonly RULE_constantExpression = 86;
    static readonly RULE_expression = 87;
    static readonly RULE_primary = 88;
    static readonly RULE_creator = 89;
    static readonly RULE_createdName = 90;
    static readonly RULE_innerCreator = 91;
    static readonly RULE_arrayCreatorRest = 92;
    static readonly RULE_classCreatorRest = 93;
    static readonly RULE_explicitGenericInvocation = 94;
    static readonly RULE_nonWildcardTypeArguments = 95;
    static readonly RULE_typeArgumentsOrDiamond = 96;
    static readonly RULE_nonWildcardTypeArgumentsOrDiamond = 97;
    static readonly RULE_superSuffix = 98;
    static readonly RULE_explicitGenericInvocationSuffix = 99;
    static readonly RULE_arguments = 100;
    static readonly ruleNames: string[];
    private static readonly _LITERAL_NAMES;
    private static readonly _SYMBOLIC_NAMES;
    static readonly VOCABULARY: Vocabulary;
    readonly vocabulary: Vocabulary;
    readonly grammarFileName: string;
    readonly ruleNames: string[];
    readonly serializedATN: string;
    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;
    typeList(): TypeListContext;
    classBody(): ClassBodyContext;
    interfaceBody(): InterfaceBodyContext;
    classBodyDeclaration(): ClassBodyDeclarationContext;
    memberDeclaration(): MemberDeclarationContext;
    methodDeclaration(): MethodDeclarationContext;
    genericMethodDeclaration(): GenericMethodDeclarationContext;
    constructorDeclaration(): ConstructorDeclarationContext;
    genericConstructorDeclaration(): GenericConstructorDeclarationContext;
    fieldDeclaration(): FieldDeclarationContext;
    interfaceBodyDeclaration(): InterfaceBodyDeclarationContext;
    interfaceMemberDeclaration(): InterfaceMemberDeclarationContext;
    constDeclaration(): ConstDeclarationContext;
    constantDeclarator(): ConstantDeclaratorContext;
    interfaceMethodDeclaration(): InterfaceMethodDeclarationContext;
    genericInterfaceMethodDeclaration(): GenericInterfaceMethodDeclarationContext;
    variableDeclarators(): VariableDeclaratorsContext;
    variableDeclarator(): VariableDeclaratorContext;
    variableDeclaratorId(): VariableDeclaratorIdContext;
    variableInitializer(): VariableInitializerContext;
    arrayInitializer(): ArrayInitializerContext;
    enumConstantName(): EnumConstantNameContext;
    typeType(): TypeTypeContext;
    classOrInterfaceType(): ClassOrInterfaceTypeContext;
    primitiveType(): PrimitiveTypeContext;
    typeArguments(): TypeArgumentsContext;
    typeArgument(): TypeArgumentContext;
    qualifiedNameList(): QualifiedNameListContext;
    formalParameters(): FormalParametersContext;
    formalParameterList(): FormalParameterListContext;
    formalParameter(): FormalParameterContext;
    lastFormalParameter(): LastFormalParameterContext;
    methodBody(): MethodBodyContext;
    constructorBody(): ConstructorBodyContext;
    qualifiedName(): QualifiedNameContext;
    literal(): LiteralContext;
    annotation(): AnnotationContext;
    annotationName(): AnnotationNameContext;
    elementValuePairs(): ElementValuePairsContext;
    elementValuePair(): ElementValuePairContext;
    elementValue(): ElementValueContext;
    elementValueArrayInitializer(): ElementValueArrayInitializerContext;
    annotationTypeDeclaration(): AnnotationTypeDeclarationContext;
    annotationTypeBody(): AnnotationTypeBodyContext;
    annotationTypeElementDeclaration(): AnnotationTypeElementDeclarationContext;
    annotationTypeElementRest(): AnnotationTypeElementRestContext;
    annotationMethodOrConstantRest(): AnnotationMethodOrConstantRestContext;
    annotationMethodRest(): AnnotationMethodRestContext;
    annotationConstantRest(): AnnotationConstantRestContext;
    defaultValue(): DefaultValueContext;
    block(): BlockContext;
    blockStatement(): BlockStatementContext;
    localVariableDeclarationStatement(): LocalVariableDeclarationStatementContext;
    localVariableDeclaration(): LocalVariableDeclarationContext;
    statement(): StatementContext;
    catchClause(): CatchClauseContext;
    catchType(): CatchTypeContext;
    finallyBlock(): FinallyBlockContext;
    resourceSpecification(): ResourceSpecificationContext;
    resources(): ResourcesContext;
    resource(): ResourceContext;
    switchBlockStatementGroup(): SwitchBlockStatementGroupContext;
    switchLabel(): SwitchLabelContext;
    forControl(): ForControlContext;
    forInit(): ForInitContext;
    enhancedForControl(): EnhancedForControlContext;
    forUpdate(): ForUpdateContext;
    parExpression(): ParExpressionContext;
    expressionList(): ExpressionListContext;
    statementExpression(): StatementExpressionContext;
    constantExpression(): ConstantExpressionContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    primary(): PrimaryContext;
    creator(): CreatorContext;
    createdName(): CreatedNameContext;
    innerCreator(): InnerCreatorContext;
    arrayCreatorRest(): ArrayCreatorRestContext;
    classCreatorRest(): ClassCreatorRestContext;
    explicitGenericInvocation(): ExplicitGenericInvocationContext;
    nonWildcardTypeArguments(): NonWildcardTypeArgumentsContext;
    typeArgumentsOrDiamond(): TypeArgumentsOrDiamondContext;
    nonWildcardTypeArgumentsOrDiamond(): NonWildcardTypeArgumentsOrDiamondContext;
    superSuffix(): SuperSuffixContext;
    explicitGenericInvocationSuffix(): ExplicitGenericInvocationSuffixContext;
    arguments(): ArgumentsContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    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 _ATN: ATN;
}