All Classes and Interfaces

Class	Description
AccessSpecifier	Access specifier.
Added
AllFieldsConstructor	Tells tools that this is the constructor which directly initializes all fields (except "range" and "comment")
AnnotationDeclaration	An annotation type declaration. @interface X { ... }
AnnotationDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
AnnotationExpr	A base class for the different types of annotations.
AnnotationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
AnnotationMemberDeclaration	The "int id();" in @interface X { int id(); }
AnnotationMemberDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ArrayAccessExpr	Array brackets [] being used to get a value from an array.
ArrayAccessExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ArrayCreationExpr	new int[5][4][][] or new int[][]{{1},{2,3}}.
ArrayCreationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ArrayCreationLevel	In new int[1][2]; there are two ArrayCreationLevel objects, the first one contains the expression "1", the second the expression "2".
ArrayCreationLevelMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ArrayInitializerExpr	The initialization of an array.
ArrayInitializerExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ArrayType	To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has.
ArrayType.ArrayBracketPair	Helper class that stores information about a pair of brackets in a non-recursive way (unlike ArrayType.)
ArrayType.Origin	The origin of a pair of array brackets [].
ArrayTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
AssertStmt	A usage of the keyword "assert" In assert dead : "Wasn't expecting to be dead here"; the check is "dead" and the message is the string.
AssertStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
AssignExpr	An assignment expression.
AssignExpr.Operator
AssignExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
AssociableToAST	A declaration that can be potentially associated with an AST node.
AstObserver	An Observer for an AST element (either a Node or a NodeList).
AstObserver.ListChangeType	Type of change occurring on a List
AstObserverAdapter
BaseNodeMetaModel	Meta-data about all classes in the AST.
BinaryExpr	An expression with an expression on the left, an expression on the right, and an operator in the middle.
BinaryExpr.Operator
BinaryExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
BlockComment	AST node that represent block comments.
BlockCommentMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
BlockStmt	Statements in between { and }.
BlockStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
BodyDeclaration<T extends BodyDeclaration<?>>	Any declaration that can appear between the { and } of a class, interface, enum, or record.
BodyDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
BooleanLiteralExpr	The boolean literals.
BooleanLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
BreakStmt	The break statement
BreakStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
CallableDeclaration<T extends CallableDeclaration<?>>	Represents a declaration which is callable eg.
CallableDeclaration.Signature	A method or constructor signature.
CallableDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
CastExpr	A typecast.
CastExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
CatchClause	The catch part of a try-catch-finally.
CatchClauseMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Change	This represents a change that has happened to a specific Node.
CharLiteralExpr	A literal character.
CharLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ChildTextElement	Represent the position of a child node in the NodeText of its parent.
ClassExpr	Defines an expression that accesses the class of a type.
ClassExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ClassOrInterfaceDeclaration	A definition of a class or interface. class X { ... } interface X { ... }
ClassOrInterfaceDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ClassOrInterfaceType	A class or an interface type.
ClassOrInterfaceTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ClassUtils
CloneVisitor	A visitor that clones (copies) a node and all its children.
CodeGenerationUtils	Utilities that can be useful when generating code.
CollectionStrategy	A strategy for discovering the structure of a project.
Comment	Abstract class for all AST nodes that represent comments.
CommentMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
CommentsCollection	The comments contained in a certain parsed piece of source code.
CommentsInserter	Assigns comments to nodes of the AST.
CommonValidators	Contains validations that are valid for every Java version.
CompactConstructorDeclaration	The record declaration's constructor
CompactConstructorDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
CompilationUnit	This class represents the entire compilation unit.
CompilationUnit.Storage	Information about where this compilation unit was loaded from.
CompilationUnitMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ConcreteSyntaxModel	The Concrete Syntax Model for a single node type.
ConditionalExpr	The ternary conditional expression.
ConditionalExprHandler
ConditionalExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ConfigurationOption
ConflictingGenericTypesException
ConstructorDeclaration	A constructor declaration: class X { X() { } } where X(){} is the constructor declaration.
ConstructorDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ConstructorResolutionLogic
Context	Context is very similar to scope.
ContinueStmt	A continue statement with an optional label; continue brains; continue;
ContinueStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ConvertibleToUsage	Convert a Type into a ResolvedType.
CsmAttribute
CsmChar
CsmComment
CsmConditional
CsmConditional.Condition
CsmElement
CsmIndent
CsmList
CsmMix	A group of elements that could be in any order.
CsmNone
CsmOrphanCommentsEnding
CsmSequence
CsmSingleReference
CsmString
CsmTextBlock
CsmToken
CsmToken.TokenContentCalculator
CsmUnindent
DataKey<T>	A key to a piece of data associated with a Node at runtime.
DefaultConfigurationOption
DefaultImportOrderingStrategy
DefaultPrettyPrinter	Pretty printer for AST nodes.
DefaultPrettyPrinterVisitor	Outputs the AST as formatted Java source code.
DefaultPrinterConfiguration	Configuration options for the Printer.
DefaultPrinterConfiguration.ConfigOption
DerivedProperty	Indicate a derived property of a Node, meaning it does supply useful information, but it does so by taking information from other properties.
Difference	A Difference should give me a sequence of elements I should find (to indicate the context) followed by a list of elements to remove or to add and follow by another sequence of elements.
Difference.MatchClassification
DifferenceElement
DifferenceElementCalculator
DifferenceElementCalculator.ChildPositionInfo
DoStmt	A do-while.
DoStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
DotPrinter	Outputs a Graphviz diagram of the AST.
DoubleLiteralExpr	A float or a double constant.
DoubleLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
EclipseImportOrderingStrategy
EmptyStmt	An empty statement is a ";" where a statement is expected.
EmptyStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
EnclosedExpr	An expression between ( ).
EnclosedExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
EnumConstantDeclaration	One of the values an enum can take.
EnumConstantDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
EnumDeclaration	The declaration of an enum. enum X { ... }
EnumDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
EqualsVisitor	A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
ExplicitConstructorInvocationStmt	A call to super or this in a constructor or initializer.
ExplicitConstructorInvocationStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Expression	A base class for all expressions.
ExpressionMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ExpressionStmt	Used to wrap an expression so that it can take the place of a statement.
ExpressionStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
FieldAccessExpr	Access of a field of an object or a class.
FieldAccessExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
FieldDeclaration	The declaration of a field in a class.
FieldDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ForEachStmt	A for-each statement.
ForEachStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ForStmt	The classic for statement
ForStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
FunctionalInterfaceLogic
Generated	Copied from javax.annotation.Generated and reduced a bit.
GeneratedJavaParser
GeneratedJavaParser.JJCalls
GeneratedJavaParser.LookaheadSuccess
GeneratedJavaParserBase	Base class for GeneratedJavaParser
GeneratedJavaParserConstants	Token literal values and constants.
GeneratedJavaParserTokenManager	Token Manager.
GeneratedJavaParserTokenManagerBase	Base class for GeneratedJavaParserTokenManager
GenericListVisitorAdapter<R,A>	A visitor that has a return value of List<R>, and has a default implementation for all its visit methods that visits their children in an unspecified order, and all visit methods that returns a value be added to a flattened List<R>.
GenericVisitor<R,A>	A visitor that has a return value.
GenericVisitorAdapter<R,A>	A visitor that has a return value (R), and has a default implementation for all its visit methods that visits their children in an unspecified order, and the first visit method that returns a value will stop the visitation and be the end result.
GenericVisitorWithDefaults<R,A>	A visitor that has a return value (R), and has default methods that are used when a specific visit method is not overridden.
HasAccessSpecifier	Anything which can have an AccessSpecifier.
HashCodeVisitor	A visitor that calculates a deep hash code for a node by using the hash codes of all its properties, and the hash codes of all its child nodes (by visiting those too.)
HasParentNode<T>	An object that can have a parent node.
IfStmt	An if-then-else statement.
IfStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ImportDeclaration	An import declaration.
ImportDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ImportOrderingStrategy
Indentation	This class defines the characteristics of an indentation: the type (space, tabs..) and the size (How many characters must be used to indent the code).
Indentation.IndentType
InferenceContext
InferenceVariableType	An element using during type inference.
InitializerDeclaration	A (possibly static) initializer body.
InitializerDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
InstanceOfExpr	The instanceof statement
InstanceOfExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
IntegerLiteralExpr	All ways to specify an int literal.
IntegerLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
IntelliJImportOrderingStrategy
InternalProperty	Indicate an internal property of a Node, meaning it is not part of the meta model.
IntersectionType	Represents a set of types.
IntersectionTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Java1_0Validator	This validator validates according to Java 1.0 syntax rules.
Java1_1Validator	This validator validates according to Java 1.1 syntax rules.
Java1_2Validator	This validator validates according to Java 1.2 syntax rules.
Java1_3Validator	This validator validates according to Java 1.3 syntax rules.
Java1_4Validator	This validator validates according to Java 1.4 syntax rules.
Java10PostProcessor	Processes the generic AST into a Java 10 AST and validates it.
Java10PreviewValidator	This validator validates according to Java 10 syntax rules -- including incubator/preview/second preview features.
Java10Validator	This validator validates according to Java 10 syntax rules.
Java11PostProcessor	Processes the generic AST into a Java 11 AST and validates it.
Java11PreviewValidator	This validator validates according to Java 11 syntax rules -- including incubator/preview/second preview features.
Java11Validator	This validator validates according to Java 11 syntax rules.
Java12PostProcessor	Processes the generic AST into a Java 12 AST and validates it.
Java12PreviewValidator	This validator validates according to Java 12 syntax rules -- including incubator/preview/second preview features.
Java12Validator	This validator validates according to Java 12 syntax rules.
Java13PostProcessor	Processes the generic AST into a Java 13 AST and validates it.
Java13PreviewValidator	This validator validates according to Java 13 syntax rules -- including incubator/preview/second preview features.
Java13Validator	This validator validates according to Java 13 syntax rules.
Java14PostProcessor	Processes the generic AST into a Java 14 AST and validates it.
Java14PreviewValidator	This validator validates according to Java 14 syntax rules -- including incubator/preview/second preview features.
Java14Validator	This validator validates according to Java 14 syntax rules.
Java15PostProcessor	Processes the generic AST into a Java 15 AST and validates it.
Java15PreviewValidator	This validator validates according to Java 15 syntax rules -- including incubator/preview/second preview features.
Java15Validator	This validator validates according to Java 15 syntax rules.
Java16PostProcessor	Processes the generic AST into a Java 16 AST and validates it.
Java16PreviewValidator	This validator validates according to Java 16 syntax rules -- including incubator/preview/second preview features.
Java16Validator	This validator validates according to Java 16 syntax rules.
Java17PostProcessor	Processes the generic AST into a Java 17 AST and validates it.
Java17PreviewValidator	This validator validates according to Java 17 syntax rules -- including incubator/preview/second preview features.
Java17Validator	This validator validates according to Java 17 syntax rules.
Java5Validator	This validator validates according to Java 5 syntax rules.
Java6Validator	This validator validates according to Java 6 syntax rules.
Java7Validator	This validator validates according to Java 7 syntax rules.
Java8Validator	This validator validates according to Java 8 syntax rules.
Java9Validator	This validator validates according to Java 9 syntax rules.
Javadoc	The structured content of a single Javadoc comment.
JavadocBlockTag	A block tag.
JavadocBlockTag.Type	The type of tag: it could either correspond to a known tag (param, return, etc.) or represent an unknown tag.
JavadocComment	A Javadoc comment.
JavadocCommentMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
JavadocDescription	A javadoc text, potentially containing inline tags.
JavadocDescriptionElement	An element of a description: either an inline tag or a piece of text.
JavadocInlineTag	An inline tag contained in a Javadoc description.
JavadocInlineTag.Type	The type of tag: it could either correspond to a known tag (code, docRoot, etc.) or represent an unknown tag.
JavadocParser	The class responsible for parsing the content of JavadocComments and producing JavadocDocuments.
JavadocSnippet	A piece of text inside a Javadoc description.
JavaParser	Parse Java source code and creates Abstract Syntax Trees.
JavaParserAdapter
JavaParserBuild	Some information that was available when this library was built by Maven.
JavaParserMetaModel	Warning: The content of this class is partially or completely generated - manual edits risk being overwritten.
JavaToken	A token from a parsed source file.
JavaToken.Category
JavaToken.Kind
Kept
LabeledStmt	A statement that is labeled, like label123: println("continuing");
LabeledStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LambdaArgumentTypePlaceholder	Placeholder used to represent a lambda argument type while it is being calculated.
LambdaExpr	A lambda expression
LambdaExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LazyType
LexicalDifferenceCalculator
LexicalDifferenceCalculator.CalculatedSyntaxModel	The ConcreteSyntaxModel represents the general format.
LexicalDifferenceCalculator.CsmChild
LexicalPreservingPrinter	A Lexical Preserving Printer is used to capture all the lexical information while parsing, update them when operating on the AST and then used them to reproduce the source code in its original formatting including the AST changes.
LexicalPreservingPrinter.Observer
LexicalPreservingVisitor
LineComment	AST node that represent line comments.
LineCommentMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LineEndingProcessingProvider	Provider un-escaping unicode escape sequences in the input sequence.
LineSeparator	A representation of line endings, that can be used throughout the codebase.
ListAdditionChange	The Addition of an element to a list.
ListRemovalChange	The removal of an element from a list.
ListReplacementChange	The replacement of an element in a list.
LiteralExpr	A base class for all literal expressions.
LiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LiteralStringValueExpr	Any literal value that is stored internally as a String.
LiteralStringValueExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LocalClassDeclarationStmt	A class declaration inside a method.
LocalClassDeclarationStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
LocalRecordDeclarationStmt	A record declaration inside a method.
LocalRecordDeclarationStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Log	To avoid dependencies on logging frameworks, we have invented yet another logging framework :-)
Log.Adapter
Log.SilentAdapter	This adapter logs nothing.
Log.StandardOutStandardErrorAdapter	This adapter logs to standard out and standard error.
LongLiteralExpr	All ways to specify a long literal.
LongLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MarkerAnnotationExpr	An annotation that uses only the annotation type name.
MarkerAnnotationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MemberValuePair	A value for a member of an annotation.
MemberValuePairMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MethodAmbiguityException	It is not possible to decide how to resolve a method invocation.
MethodCallExpr	A method call on an object or a class.
MethodCallExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MethodDeclaration	A method declaration.
MethodDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MethodReferenceExpr	Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions.
MethodReferenceExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
MethodResolutionCapability
MethodResolutionLogic
MethodUsage	This is basically a MethodDeclaration with some TypeParameters defined.
Modifier	A modifier, like private, public, or volatile.
Modifier.Keyword	The Java modifier keywords.
ModifierHolder	Helper class for GeneratedJavaParser
ModifierMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModifierValidator	Verifies that only allowed modifiers are used where modifiers are expected.
ModifierVisitor<A>	This visitor can be used to save time when some specific nodes needs to be changed.
ModuleDeclaration	A Java 9 Jigsaw module declaration.
ModuleDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleDirective	A module directive.
ModuleDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleExportsDirective	An exports directive in module-info.java.
ModuleExportsDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleOpensDirective	An opens directive in module-info.java.
ModuleOpensDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleProvidesDirective	A provides directive in module-info.java.
ModuleProvidesDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleRequiresDirective	A require directive in module-info.java.
ModuleRequiresDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ModuleUsesDirective	A uses directive in module-info.java.
ModuleUsesDirectiveMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Name	A name that may consist of multiple identifiers.
NameExpr	Whenever a SimpleName is used in an expression, it is wrapped in NameExpr.
NameExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
NameMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Navigator	This class can be used to easily retrieve nodes from a JavaParser AST.
NoBinaryIntegerLiteralsValidator
NoChange	No change.
NoCommentEqualsVisitor
NoCommentHashCodeVisitor
Node	Base class for all nodes of the abstract syntax tree.
Node.BreadthFirstIterator	Performs a breadth-first node traversal starting with a given node.
Node.DirectChildrenIterator	Performs a simple traversal over all nodes that have the passed node as their parent.
Node.ObserverRegistrationMode	Different registration mode for observers on nodes.
Node.ParentsVisitor	Iterates over the parent of the node, then the parent's parent, then the parent's parent's parent, until running out of parents.
Node.Parsedness
Node.PostOrderIterator	Performs a post-order (or leaves-first) node traversal starting with a given node.
Node.PreOrderIterator	Performs a pre-order (or depth-first) node traversal starting with a given node.
Node.TreeTraversal
NodeList<N extends Node>	A list of nodes.
NodeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
NodeText	This contains the lexical information for a single node.
NodeWithAbstractModifier<N extends Node>	A node that can be abstract.
NodeWithAccessModifiers<N extends Node>	A node that can be public, protected, and/or private.
NodeWithAnnotations<N extends Node>	A node that can be annotated.
NodeWithArguments<N extends Node>	A node with arguments.
NodeWithBlockStmt<N extends Node>	A node with a body that is a BlockStmt.
NodeWithBody<N extends Node>
NodeWithCondition<N extends Node>
NodeWithDeclaration	Node with a declaration representable as a String.
NodeWithExpression<N extends Node>	A node that has an expression in it.
NodeWithExtends<N extends Node>	A node that explicitly extends other types, using the extends keyword.
NodeWithFinalModifier<N extends Node>	A node that can be final.
NodeWithIdentifier<N extends Node>
NodeWithImplements<N extends Node>	A node that implements other types.
NodeWithJavadoc<N extends Node>	A node that can be documented with a Javadoc comment.
NodeWithMembers<N extends Node>	A node having members.
NodeWithModifiers<N extends Node>	A Node with Modifiers.
NodeWithName<N extends Node>	A node with a (qualified) name.
NodeWithOptionalBlockStmt<N extends Node>	A node with a body that is a BlockStmt, which is optional.
NodeWithOptionalLabel<T extends Node>	A node that has an optional label.
NodeWithOptionalScope<N extends Node>	Represents a node which has an optional scope expression eg.
NodeWithParameters<N extends Node>
NodeWithPrivateModifier<N extends Node>	A node that can be private.
NodeWithProtectedModifier<N extends Node>	A node that can be protected.
NodeWithPublicModifier<N extends Node>	A node that can be public.
NodeWithRange<N>	A node that has a Range, which is every Node.
NodeWithScope<N extends Node>	Represents a node which has a required scope expression eg.
NodeWithSimpleName<N extends Node>	A node with a name.
NodeWithStatements<N extends Node>	A node that contains a list of statements.
NodeWithStaticModifier<N extends Node>	A node that can be static.
NodeWithStrictfpModifier<N extends Node>	A node that can be strictfp.
NodeWithThrownExceptions<N extends Node>	A node that declares the types of exception it throws.
NodeWithTokenRange<N>	A node that has a Range, which is every Node.
NodeWithTraversableScope	Represents a node which has a scope expression that can be traversed/walked.
NodeWithType<N extends Node,T extends Type>	A node with a type.
NodeWithTypeArguments<N extends Node>	A node that can have type arguments.
NodeWithTypeParameters<N extends Node>	A node that can have type parameters.
NodeWithVariables<N extends Node>	A node which has a list of variables.
NonEmptyProperty	Indicate that leaving this property empty does not lead to a correct AST.
NormalAnnotationExpr	An annotation that has zero or more key-value pairs. @Mapping(a=5, d=10)
NormalAnnotationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
NotNull
NoUnderscoresInIntegerLiteralsValidator
Nullable
NullLiteralExpr	A literal "null".
NullLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
NullType	This is a virtual type used to represent null values.
ObjectCreationExpr	A constructor call.
ObjectCreationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ObjectIdentityEqualsVisitor	A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
ObjectIdentityHashCodeVisitor	A visitor that calculates a deep hash code for a node by using the hash codes of all its properties, and the hash codes of all its child nodes (by visiting those too.)
Observable	Observable element.
ObservableProperty	Properties considered by the AstObserver
ObservableProperty.Type
OptionalProperty	Indicate an optional property of a Node.
PackageDeclaration	A package declaration.
PackageDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Pair<A,B>	Simply a pair of objects.
Parameter	The parameters to a method or lambda.
ParameterMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ParseException	This exception is thrown when parse errors are encountered.
ParseProblemException	Thrown when parsing problems occur during parsing with the static methods on JavaParser.
ParserCollectionStrategy	A brute force CollectionStrategy for discovering a project structure.
ParserConfiguration	The configuration that is used by the parser.
ParserConfiguration.LanguageLevel
ParseResult<T>	The results given when parsing with an instance of JavaParser.
ParseStart<R>	The start production for JavaParser.
PatternExpr	The instanceof statement
PatternExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
PhantomNodeLogic	Deprecated. This class is no longer used phantom node are now an attribute of each node
Position	A position in a source file.
PositionUtils
PostProcessors	A post processor that will call a collection of post processors.
Preconditions
PrettyPrinter	Deprecated. This class could be removed in a future version.
PrettyPrinterConfiguration	Deprecated. This class could be removed in a future version.
PrettyPrintVisitor	Deprecated. This class is no longer acceptable to use because it is not sufficiently configurable and it is too tied to a specific implementation.
PrimitiveType	A primitive type.
PrimitiveType.Primitive
PrimitiveTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
PrintableTextElement
Printer	Printer interface defines the API for a printer.
PrinterConfiguration	This interface defines the API for printer configuration.
PrintingHelper
Problem	A problem that was encountered during parsing.
ProblemReporter	A simple interface where validators can report found problems.
Processor
ProjectRoot	The structure of a Java project directory.
PropagatingAstObserver	This AstObserver attach itself to all new nodes added to the nodes already observed.
PropertyChange	The change in value of a property.
PropertyMetaModel	Meta-data about a property of a node in the AST.
Provider
Providers	Factory for providers of source code for JavaParser.
Range	A range of characters in a source file, from "begin" to "end", including the characters at "begin" and "end".
RangedList<T extends Node>	Helper class for GeneratedJavaParser
ReceiverParameter	The receiver parameter feature of Java.
ReceiverParameterMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
RecordAsTypeIdentifierNotAllowed	Validates that "record" cannot be used as identifier for type declarations (e.g., classes, enums, and records).
RecordDeclaration	The record declaration
RecordDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
RecordDeclarationValidator
ReferenceType	Base class for reference types.
ReferenceTypeImpl
ReferenceTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Removed
RemovedGroup	This class represents a group of Removed elements.
ReservedKeywordValidator	Validates that identifiers are not keywords - this for the few keywords that the parser accepts because they were added after Java 1.0.
Reshuffled	Elements in a CsmMix have been reshuffled.
Resolvable<T>
ResolvedAnnotationDeclaration
ResolvedAnnotationMemberDeclaration
ResolvedArrayType	Array Type.
ResolvedClassDeclaration	Declaration of a Class (not an interface or an enum).
ResolvedConstructorDeclaration	A declaration of a constructor.
ResolvedDeclaration	A generic declaration.
ResolvedEnumConstantDeclaration
ResolvedEnumDeclaration	Declaration of an Enum.
ResolvedFieldDeclaration	Declaration of a field.
ResolvedInterfaceDeclaration	An interface declaration.
ResolvedIntersectionType	An intersection type is defined in java as list of types separates by ampersands.
ResolvedLambdaConstraintType
ResolvedMethodDeclaration	A declaration of a method (either in an interface, a class, an enum or an annotation).
ResolvedMethodLikeDeclaration	This is a common interface for MethodDeclaration and ConstructorDeclaration.
ResolvedParameterDeclaration	Declaration of a parameter.
ResolvedPatternDeclaration	Declaration of a pattern expression.
ResolvedPrimitiveType
ResolvedReferenceType	A ReferenceType like a class, an interface or an enum.
ResolvedReferenceTypeDeclaration
ResolvedType	A resolved type.
ResolvedTypeDeclaration	A declaration of a type.
ResolvedTypeParameterDeclaration	Declaration of a type parameter.
ResolvedTypeParameterDeclaration.Bound	A Bound on a Type Parameter.
ResolvedTypeParametersMap	A map of values associated to TypeParameters.
ResolvedTypeParametersMap.Builder
ResolvedTypeParameterValueProvider
ResolvedTypeParametrizable	An entity which has type parameter.
ResolvedTypeParametrized	Something which can have values for TypeParameters.
ResolvedTypeTransformer
ResolvedTypeVariable	From JLS 4.4: A type variable is introduced by the declaration of a type parameter of a generic class, interface, method, or constructor (§8.1.2, §9.1.2, §8.4.4, §8.8.4).
ResolvedUnionType	A union type is defined in java as list of types separates by pipes.
ResolvedValueDeclaration	Declaration of a value.
ResolvedVoidType	The special type void.
ResolvedWildcard	A wildcard can be: - unbounded (?) - have a lower bound (? super Number) - have an upper bound (? extends Number) It is not possible to have both a lower and an upper bound at the same time.
ResolvedWildcard.BoundType
ReturnStmt	The return statement, with an optional expression to return.
ReturnStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SeparatedItemStringBuilder	Builds a string containing a list of items with a prefix, a postfix, and a separator.
SimpleCharStream	An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
SimpleName	A name that consists of a single identifier.
SimpleNameMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SimpleValidator<N extends Node>	Runs a validator on all nodes of a certain type, and adds a problem for all nodes that pass a condition.
SingleMemberAnnotationExpr	An annotation that has a single value.
SingleMemberAnnotationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SingleNodeTypeValidator<N extends Node>	Runs a validator on all nodes of a certain type.
Solver
SourcePrinter	A support class for code that outputs formatted source code.
SourceRoot	A collection of Java source files located in one directory and its subdirectories on the file system.
SourceRoot.Callback
SourceRoot.Callback.Result
SourceRoot.ParallelParse	Executes a recursive file tree walk using threads.
SourceRoot.ParallelParse.VisitFileCallback
SourceZip	A collection of Java source files and its sub-directories located in a ZIP or JAR file on the file system.
SourceZip.Callback	An interface to define a callback for each file that's parsed.
Statement	A base class for all statements.
StatementMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
StaticJavaParser	A simpler, static API than JavaParser.
StreamProvider	NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)
Stringable	Something that has a printable form.
StringEscapeUtils	Adapted from apache commons-lang3 project.
StringEscapeUtils.AggregateTranslator	Adapted from apache commons-lang3 project.
StringEscapeUtils.CharSequenceTranslator	Adapted from apache commons-lang3 project.
StringEscapeUtils.LookupTranslator	Adapted from apache commons-lang3 project.
StringEscapeUtils.OctalUnescaper	Adapted from apache commons-lang3 project.
StringEscapeUtils.UnicodeUnescaper	Adapted from apache commons-lang3 project.
StringLiteralExpr	A literal string.
StringLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
StringProvider
SuperExpr	An occurrence of the "super" keyword.
SuperExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SwitchEntry	One case in a switch statement
SwitchEntry.Type
SwitchEntryMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SwitchExpr	The switch expression
SwitchExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SwitchNode	The common interface of SwitchExpr and SwitchStmt
SwitchStmt	The switch statement
SwitchStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
SymbolDeclarator
SymbolReference<S extends ResolvedDeclaration>	A reference to a symbol.
SymbolResolver
SynchronizedStmt	Usage of the synchronized keyword.
SynchronizedStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TextBlockLiteralExpr	A text block
TextBlockLiteralExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TextElement
TextElementIteratorsFactory
TextElementIteratorsFactory.CascadingIterator<E>
TextElementIteratorsFactory.CascadingIterator.Provider<E>
TextElementIteratorsFactory.ComposedIterator<E>
TextElementIteratorsFactory.EmptyIterator<E>
TextElementIteratorsFactory.SingleElementIterator<E>
TextElementMatcher
TextElementMatchers
ThisExpr	An occurrence of the "this" keyword.
ThisExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
ThrowStmt	Usage of the throw statement.
ThrowStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Token	Describes the input token stream.
TokenBase	Base class for the generated Token
TokenMgrException	Token Manager Error.
TokenRange	The range of tokens covered by this node.
TokenTextElement
TokenTypes	Complements GeneratedJavaParserConstants
TreeVisitor	Iterate over all the nodes in (a part of) the AST.
TreeVisitorValidator	A validator that walks the whole tree, visiting every node.
TryStmt	The try statement
TryStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
Type	Base class for types.
TypeDeclaration<T extends TypeDeclaration<?>>	A base class for all types of type declarations.
TypeDeclarationMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TypedValidator<N extends Node>	A validator that validates a known node type.
TypeExpr	This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types.
TypeExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TypeParameter	A type parameter.
TypeParameterMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
TypeSolver	An element able to find TypeDeclaration from their name.
TypeUtils
UnaryExpr	An expression where an operator is applied to a single expression.
UnaryExpr.Operator
UnaryExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
UnderscoreKeywordValidator
UnicodeEscapeProcessingProvider	Provider un-escaping unicode escape sequences in the input sequence.
UnicodeEscapeProcessingProvider.LineCounter	Processor keeping track of the current line and column in a stream of incoming characters.
UnicodeEscapeProcessingProvider.PositionMapping	An algorithm mapping Position form two corresponding files.
UnicodeEscapeProcessingProvider.PositionMapping.DeltaInfo
UnicodeEscapeProcessingProvider.PositionMapping.PositionUpdate	Algorithm updating a Position from one file to a Position in a corresponding file.
UnicodeEscapeProcessingProvider.PositionMappingBuilder
UnionType	The union type
UnionTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
UnknownType	An unknown parameter type object.
UnknownTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
UnparsableStmt	A statement that had parse errors.
UnparsableStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
UnsolvedSymbolException	This exception is thrown when a symbol cannot be resolved.
Utils	Any kind of utility.
Validator	A validator that can be run on a node to check for semantic errors.
Validators	A validator that will call a collection of validators.
Value	Any type of value.
VariableDeclarationExpr	A declaration of variables.
VariableDeclarationExprMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
VariableDeclarator	The declaration of a variable. In int x = 14, y = 3; "int x = 14" and "int y = 3" are VariableDeclarators.
VariableDeclaratorMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
VarType	A type called "var" waiting for Java to infer it.
VarTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
VarValidator
Visitable
VisitorList<N extends Node>	A list that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.
VisitorMap<N extends Node,V>	A map that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.
VisitorSet<N extends Node>	A set that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.
VisitorValidator	A validator that uses a visitor for validation.
VoidType	The return type of a MethodDeclaration when it returns void.
VoidTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
VoidVisitor<A>	A visitor that does not return anything.
VoidVisitorAdapter<A>	A visitor that returns nothing, and has a default implementation for all its visit methods that simply visit their children in an unspecified order.
VoidVisitorWithDefaults<A>	A visitor that returns nothing, and has default methods that are used when a specific visit method is not overridden.
WhileStmt	A while statement.
WhileStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
WildcardType	A wildcard type argument.
WildcardTypeMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.
XmlPrinter	Outputs an XML file containing the AST meant for inspecting it.
YamlPrinter	Outputs a YAML file containing the AST meant for inspecting it.
YieldStmt	The yield statement
YieldStmtMetaModel	This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.