All Classes

Class	Description
AbstractElementUtilsDecorator
AbstractJavaTimeToStringConversion	Base type for mapping Java 8 time types to String and vice versa.
AbstractJodaTypeToStringConversion	Base class for conversions between Joda-Time types and String.
AbstractMappingMethodBuilder<B extends AbstractMappingMethodBuilder<B,M>,M extends MappingMethod>	An abstract builder that can be reused for building MappingMethod(s).
AbstractNumberToStringConversion	Abstract base class for PrimitiveToStringConversion, WrapperToStringConversion, BigDecimalToStringConversion and BigIntegerToStringConversion Contains shared utility methods.
AbstractReference	Class acts as a common base class for TargetReference and SourceReference.
AbstractToXmlGregorianCalendar
AbstractTypeUtilsDecorator	Replaces the usage of TypeUtils within MapStruct by delegating to the original implementation or to our specific workarounds if necessary.
Accessibility	Accessibility of an element
Accessor	This represents an Accessor that can be used for writing/reading a property to/from a bean.
AccessorNamingStrategy	A service provider interface for the mapping between method names and properties.
AccessorNamingUtils	Utils for working with the AccessorNamingStrategy.
AccessorType
AdderWrapper	Wraps the assignment in a target setter.
AdditionalAnnotationsBuilder
AdditionalSupportedOptionsProvider	Provider for any additional supported options required for custom SPI implementations.
AfterMapping	Marks a method to be invoked at the end of a generated mapping method, right before the last return statement of the mapping method.
AllPresenceChecksPresenceCheck
AnnotatedConstructor	Represents a constructor that is used for constructor injection.
AnnotatedSetter
AnnotateWith	This can be used to have mapstruct generate additional annotations on classes/methods.
AnnotateWith.Element	Used in combination with AnnotateWith to configure the annotation elements.
AnnotateWiths	This can be used to have mapstruct generate additional annotations on classes/methods.
Annotation	Represents a Java 5 annotation.
AnnotationBasedComponentModelProcessor	An ModelElementProcessor which converts the given Mapper object into an annotation based component model in case a matching model is selected as target component model for this mapper.
AnnotationElement
AnnotationElement.AnnotationElementType
AnnotationMapperReference	Mapper reference which is retrieved via Annotation-based dependency injection. The dependency injection may vary between field and constructor injection.
AnnotationProcessingException	Indicates an error during annotation processing.
AnnotationProcessorContext	Keeps contextual data in the scope of the entire annotation processor ("application scope").
ArrayCopyWrapper	Decorates the assignment as a Map or Collection constructor
Assignment	Assignment represents all kind of manners a source can be assigned to a target.
Assignment.AssignmentType
AssignmentWrapper	Base class for decorators (wrappers).
AstModifyingAnnotationProcessor	A contract to be implemented by other annotation processors which - against the design philosophy of JSR 269 - alter the types under compilation.
BeanMapping	Configures the mapping between two bean types.
BeanMappingMethod	A MappingMethod implemented by a Mapper class which maps one bean type to another, optionally configured by one or more PropertyMappings.
BeanMappingMethod.Builder
BeanMappingOptions	Represents an bean mapping as configured via @BeanMapping.
BeforeMapping	Marks a method to be invoked at the beginning of a generated mapping method.
BigDecimalToBigIntegerConversion	Conversion between BigDecimal and BigInteger.
BigDecimalToPrimitiveConversion	Conversion between BigDecimal and native number types.
BigDecimalToStringConversion	Conversion between BigDecimal and String.
BigDecimalToWrapperConversion	Conversion between BigDecimal and wrappers of native number types.
BigIntegerToPrimitiveConversion	Conversion between BigInteger and native number types.
BigIntegerToStringConversion	Conversion between BigInteger and String.
BigIntegerToWrapperConversion	Conversion between BigInteger and wrappers of native number types.
Builder	Configuration of builders, e.g. the name of the final build method.
BuilderFinisherMethodResolver
BuilderInfo	Holder for the builder information.
BuilderInfo.Builder
BuilderProvider	A service provider interface that is used to detect types that require a builder for mapping.
BuilderType
BuiltInMappingMethods	Registry for all built-in methods.
BuiltInMethod	Represents a "built-in" mapping method which will be added as private method to the generated mapper.
CalendarToXmlGregorianCalendar
CalendarToZonedDateTime	BuiltInMethod for mapping between Calendar and ZonedDateTime.
CaseEnumTransformationStrategy	Applies case transformation to the source enum
CdiComponentProcessor	A ModelElementProcessor which converts the given Mapper object into an application-scoped CDI bean in case CDI is configured as the target component model for this mapper.
CharToStringConversion	Conversion between char and String.
CharWrapperToStringConversion	Conversion between Character and String.
CollectionAssignmentBuilder	A builder that is used for creating an assignment to a collection.
CollectionMappingStrategy	Strategy for propagating the value of collection-typed properties from source to target.
Collections	Provides utility methods around collections.
Condition	This annotation marks a method as a presence check method to check for presence in beans or it can be used to define additional check methods for something like source parameters.
ConditionMethodOptions	Encapsulates all options specific for a condition check method.
ConditionOptions
ConditionStrategy	Strategy for defining what to what a condition (check) method is applied to
Constructor	Basic interface class that facilitates an empty constructor.
ConstructorFragment	ConstructorFragments are 'code snippets' added to the constructor to initialize fields used by BuiltInMethod/HelperMethod
ContainerMappingMethod	A MappingMethod implemented by a Mapper class which does mapping of generic types.
ContainerMappingMethodBuilder<B extends ContainerMappingMethodBuilder<B,M>,M extends ContainerMappingMethod>	Builder that can be used to build ContainerMappingMethod(s).
Context	Marks a parameter of a method to be treated as mapping context.
ConversionContext	Context object passed to conversion providers and built-in methods.
ConversionProvider	Implementations create inline TypeConversions such as (long)source, Integer.valueOf(source) or new SimpleDateFormat().format( source ).
Conversions	Holds built-in ConversionProviders such as from int to String.
ConversionUtils	Methods mainly used in SimpleConversion classes, e. g.
CreateDecimalFormat	HelperMethod that creates a DecimalFormat DecimalFormat df = new DecimalFormat( numberFormat ) with setParseBigDecimal set to true.
CreateOrUpdateSelector	Selection based on type of method (create - or update method).
CurrencyToStringConversion
DateToSqlDateConversion	Conversion between Date and Date.
DateToSqlTimeConversion	Conversion between Date and Time.
DateToSqlTimestampConversion	Conversion between Date and Timestamp.
DateToStringConversion	Conversion between String and Date.
DateToXmlGregorianCalendar
DecoratedWith	Specifies a decorator to be applied to a generated mapper, which e.g. can be used to amend mappings performed by generated mapping methods.
Decorator	Represents a decorator applied to a generated mapper type.
Decorator.Builder
DecoratorConstructor	Represents the constructor of a decorator.
DeepClone	Clones a source type to a target type (assuming source and target are of the same type).
DefaultAccessorNamingStrategy	The default JavaBeans-compliant implementation of the AccessorNamingStrategy service provider interface.
DefaultBuilderProvider	Default implementation of BuilderProvider.
DefaultConversionContext	Default implementation of the ConversionContext passed to conversion providers.
DefaultEnumMappingStrategy
DefaultMapperReference	Mapper reference which is retrieved via the Mappers#getMapper() method.
DefaultModelElementProcessorContext	Default implementation of the processor context.
DefaultOptions
DefaultVersionInformation	Provides information about the processor version and the processor context implementation version.
DelegateAccessor
DelegatingMethod	A method of a decorator which delegates to the corresponding method of the generated mapper implementation.
DelegatingOptions	Chain Of Responsibility Pattern.
EclipseElementUtilsDecorator
EclipseTypeUtilsDecorator
ElementAccessor	An Accessor that wraps a VariableElement.
ElementUtils
EnumAnnotationElementHolder
EnumConstantWrapper
EnumMapping	Configured the mapping between two value types.
EnumMappingOptions
EnumMappingStrategy	A service provider interface for the mapping between different enum constants
EnumStringConversion	Conversion between String and Enum types.
EnumToIntegerConversion	Conversion between Enum and Integer types.
EnumTransformationStrategy	A service provider interface for transforming name based value mappings.
ExecutableElementAccessor	An Accessor that wraps an ExecutableElement.
Executables	Provides functionality around ExecutableElements.
ExistingInstanceSetterWrapperForCollectionsAndMaps	This wrapper handles the situation where an assignment is done for an update method.
Experimental	Features that are marked with this annotation are considered experimental.
Extractor<T,R>	This is a helper interface until we migrate to Java 8.
FactoryParameterSelector	For factory methods, the candidate list is checked if it contains a method with a source parameter which is to be favored compared to factory methods without a source parameter.
Field	A field of a mapper type, e.g. a reference to another mapper.
FieldReference	reference used by BuiltInMethod/HelperMethod to create an additional field in the mapper.
Fields	Provides functionality around VariableElements.
Filters	Filter methods for working with Element collections.
FinalField	A mapper instance field, initialized as null
ForgedMethod	This method will be generated in absence of a suitable abstract method to implement.
ForgedMethodHistory	Keeps the context where the ForgedMethod is generated, especially handy with nested forged methods
FormattingMessager	Prints out diagnostics raised by the annotation processor.
FormattingParameters
FreeBuilderAccessorNamingStrategy	Accessor naming strategy for FreeBuilder.
FreeBuilderConstants	Helper for holding FreeBuilder FQN.
FreeMarkerModelElementWriter	Delegate for writing given Writables into a Writer using FreeMarker templates.
FreeMarkerWritable	A Writable which uses the FreeMarker template engine to generate the output.
GeneratedType	A type generated by MapStruct, e.g. representing a mapper type.
GeneratedType.GeneratedTypeBuilder<T extends GeneratedType.GeneratedTypeBuilder>
GeneratedTypeMethod
GetDateTimeFormatterField
GetterWrapperForCollectionsAndMaps	This wrapper handles the situation were an assignment must be done via a target getter method because there is no setter available.
GraphAnalyzer	Analyzes graphs: Discovers all descendants of given nodes and detects cyclic dependencies between nodes if present.
GraphAnalyzer.GraphAnalyzerBuilder
HelperMethod	A non mapping method to be generated.
IgnoreJRERequirement
ImmutablesAccessorNamingStrategy	Accessor naming strategy for Immutables.
ImmutablesBuilderProvider	Builder provider for Immutables.
ImmutablesConstants	Helper for holding Immutables FQN.
ImplementationType	This is a wrapper class for the Implementation types that are used within MapStruct.
InheritanceSelector	Selects on inheritance distance, e.g. the amount of inheritance steps from the parameter type.
InheritConfiguration	Advises the code generator to apply the configuration (as given via Mapping, IterableMapping etc.)
InheritInverseConfiguration	Advises the code generator to apply all the Mappings from an inverse mapping method to the annotated method as well.
InjectionStrategy	Strategy for handling injection.
IntrospectorUtils	Utilities for tools to learn about the properties, events, and methods supported by a target Java Bean.
IterableCreation	Model element that can be used to create a type of Iterable or Map.
IterableMapping	Configures the mapping between two iterable like types, e.g.
IterableMappingMethod	A MappingMethod implemented by a Mapper class which maps one iterable type to another.
IterableMappingMethod.Builder
IterableMappingOptions	Represents an iterable mapping as configured via @IterableMapping.
JakartaCdiComponentProcessor	A ModelElementProcessor which converts the given Mapper object into an application-scoped Jakarta CDI bean in case Jakarta CDI is configured as the target component model for this mapper.
JakartaComponentProcessor	A ModelElementProcessor which converts the given Mapper object into a Jakarta Inject style bean in case "jakarta" is configured as the target component model for this mapper.
Java8FunctionWrapper	Wraps the assignment in a Function to be used in Java 8 map methods
JavacElementUtilsDecorator
JavacTypeUtilsDecorator
Javadoc	Represents the javadoc information that should be generated for a Mapper.
Javadoc	Allows the definition of Javadoc comments in the MapStruct Mapper generated class.
Javadoc.Builder
JavaExpressionPresenceCheck
JavaInstantToDateConversion	SimpleConversion for mapping Instant to Date and vice versa.
JavaLocalDateTimeToDateConversion	SimpleConversion for mapping LocalDateTime to Date and vice versa.
JavaLocalDateTimeToLocalDateConversion	SimpleConversion for mapping LocalDateTime to LocalDate and vice versa.
JavaLocalDateTimeToStringConversion	Specialization of AbstractJavaTimeToStringConversion for converting LocalDateTime
JavaLocalDateToDateConversion	SimpleConversion for mapping LocalDate to Date and vice versa.
JavaLocalDateToSqlDateConversion	SimpleConversion for mapping LocalDate to Date and vice versa.
JavaLocalDateToStringConversion	Specialization of AbstractJavaTimeToStringConversion for converting LocalDate
JavaLocalTimeToStringConversion	Specialization of AbstractJavaTimeToStringConversion for converting LocalTime
JavaStreamConstants	Helper holding Java Stream full qualified class names for conversion registration
JavaZonedDateTimeToDateConversion	SimpleConversion for mapping ZonedDateTime to Date and vice versa.
JavaZonedDateTimeToStringConversion	Specialization of AbstractJavaTimeToStringConversion for converting ZonedDateTime
JaxbConstants	Helper holding JAXB time full qualified class names for conversion registration
JodaDateTimeToCalendarConversion	Conversion between DateTime and Calendar.
JodaDateTimeToStringConversion	Conversion between DateTime and String.
JodaDateTimeToXmlGregorianCalendar
JodaLocalDateTimeToStringConversion	Conversion between LocalDateTime and String.
JodaLocalDateTimeToXmlGregorianCalendar
JodaLocalDateToStringConversion	Conversion between LocalDate and String.
JodaLocalDateToXmlGregorianCalendar
JodaLocalTimeToStringConversion	Conversion between LocalTime and String.
JodaLocalTimeToXmlGregorianCalendar
JodaTimeConstants	Helper holding constants for working with Joda-Time.
JodaTimeToDateConversion	Conversion between the following Joda types and Date: org.joda.time.DateTime org.joda.time.LocalDateTime org.joda.time.LocalDate
Jsr330ComponentProcessor	A ModelElementProcessor which converts the given Mapper object into a JSR 330 style bean in case "jsr330" is configured as the target component model for this mapper.
LifecycleCallbackMethodReference	Represents a reference to a method that is annotated with @BeforeMapping or @AfterMapping.
LifecycleMethodResolver	Factory for creating lists of appropriate LifecycleCallbackMethodReferences
LocalDateTimeToXmlGregorianCalendar
LocalDateToXmlGregorianCalendar
LocaleToStringConversion	Conversion between Locale and String.
LocalVarWrapper	Decorates an assignment as local variable.
MapMapping	Configures the mapping between two map types, e.g.
MapMappingMethod	A MappingMethod implemented by a Mapper class which maps one Map type to another.
MapMappingMethod.Builder
MapMappingOptions	Represents a map mapping as configured via @MapMapping.
Mapper	Represents a type implementing a mapper interface (annotated with @Mapper).
Mapper	Marks an interface or abstract class as a mapper and activates the generation of a implementation of that type via MapStruct.
Mapper.Builder
MapperAnnotatedFormattingMessenger	Handles redirection of errors/warnings so that they're shown on the mapper instead of hidden on a superclass.
MapperConfig	Marks a class or interface as configuration source for generated mappers.
MapperConfigOptions
MapperCreationProcessor	A ModelElementProcessor which creates a Mapper from the given list of SourceMethods.
MapperOptions
MapperReference	A reference to another mapper class, which itself may be generated or hand-written.
MapperRenderingProcessor	A ModelElementProcessor which creates a Java source file representing the given Mapper object, unless the given mapper type is erroneous.
Mappers	Factory for obtaining mapper instances if no explicit component model such as CDI is configured via Mapper.componentModel().
MapperServiceProcessor	A ModelElementProcessor which creates files in the META-INF/services hierarchy for classes with custom implementation class or package name.
Mapping	Configures the mapping of one bean attribute.
MappingBuilderContext	This class provides the context for the builders.
MappingBuilderContext.MappingResolver	Resolves the most suitable way for mapping an element (property, iterable element etc.) from source to target.
MappingConstants	Contains all constants defined in the mapping process.
MappingConstants.ComponentModel	Specifies the component model constants to which the generated mapper should adhere.
MappingControl
MappingControl	Controls which means of mapping are considered between the source and the target in mappings.
MappingControl.Use
MappingControls	Allows multiple MappingControl on a class declaration.
MappingExclusionProvider	A service provider interface that is used to control if MapStruct is allowed to generate automatic sub-mapping for a given TypeElement.
MappingInheritanceStrategy	Strategy for inheriting configurations given for methods of prototype mapping methods (declared on mapper config classes) to actual mapping methods declared on mappers referring to such config class via Mapper.config().
MappingMethod	A method implemented or referenced by a Mapper class.
MappingMethodOptions	Encapsulates all options specifiable on a mapping method
MappingMethodUtils
MappingOptions	Represents a property mapping as configured via @Mapping (no intermediate state).
MappingOptions.InheritContext
MappingProcessor	A JSR 269 annotation Processor which generates the implementations for mapper interfaces (interfaces annotated with @Mapper).
MappingReference	Represents the intermediate (nesting) state of the MappingOptions in this class.
MappingReferences
MappingResolverImpl	The one and only implementation of MappingBuilderContext.MappingResolver.
Mappings	Configures the mappings of several bean attributes.
MappingTarget	Declares a parameter of a mapping method to be the target of the mapping.
MapStructProcessingEnvironment	MapStruct will provide the implementations of its SPIs with on object implementing this interface so they can use facilities provided by it.
MapValueAccessor	An Accessor that wraps a Map value.
Message	A message used in warnings/errors raised by the annotation processor.
MessageConstants
MetaAnnotations<G extends org.mapstruct.tools.gem.Gem,V>
Method	This interface makes available common method properties and a matching method There are 2 known implementors: BuiltInMethod and SourceMethod
MethodFamilySelector	Selects those methods from the given input set which match for the requested family of methods: factory methods, lifecycle callback methods, or any other mapping methods.
MethodMatcher	SourceMethodMatcher $8.4 of the JavaLanguage specification describes a method body as such:
MethodReference	Represents a reference to another method, e.g. used to map a bean property from source to target type or to instantiate the return value of a mapping method (rather than calling the new operator).
MethodReferencePresenceCheck
MethodRetrievalProcessor	A ModelElementProcessor which retrieves a list of SourceMethods representing all the mapping methods of the given bean mapper type as well as all referenced mapper methods declared by other mappers referenced by the current mapper.
MethodSelectors	Applies all known MethodSelectors in order.
MethodType	Different types of a method.
ModelElement	Base class of all model elements.
ModelElementProcessor<P,R>	A processor which performs one task of the mapper generation, e.g. retrieving methods from the source TypeElement, performing validity checks or generating the output source file.
ModelElementProcessor.ProcessorContext	Context object passed to ModelElementProcessor.process(ProcessorContext, TypeElement, Object) providing access to common infrastructure objects such as TypeUtils etc.
ModelIncludeDirective	A TemplateDirectiveModel which allows to recursively write a graph of Writables, with each element using its own template.
ModelWriter	Writes Java source files based on given mapper models, using a FreeMarker template.
MoreThanOneBuilderCreationMethodException	Indicates that a type has too many builder creation methods.
MostSpecificResultTypeSelector
Named	Marks mapping methods with the given qualifier name.
NativeTypes	Provides functionality around the Java primitive data types and their wrapper types.
NegatePresenceCheck
NestedPropertyMappingMethod	This method is used to convert the nested properties as listed in propertyEntries into a method that creates a mapping from the start of this list to the end of the list.
NestedPropertyMappingMethod.Builder
NestedPropertyMappingMethod.SafePropertyEntry
NestedTargetPropertyMappingHolder	This is a helper class that holds the generated PropertyMapping(s) and all the information associated with it for nested target properties.
NestedTargetPropertyMappingHolder.Builder
NewDatatypeFactoryConstructorFragment
NewInstanceSetterWrapperForCollectionsAndMaps	This wrapper handles the situation where an assignment is done via the setter, while creating the collection or map using a no-args constructor.
NoArgumentConstructor	Represents a constructor that is used for constructor injection.
NoComplexMapping	Disables complex mappings, mappings that require 2 mapping means (method, built-in conversion) to constitute a mapping from source to target.
NoOpBuilderProvider	A NoOp BuilderProvider which returns null when searching for a builder.
NormalTypeMappingMethod	A MappingMethod that is used by the main mapping methods (BeanMappingMethod, MapMappingMethod, IterableMappingMethod and StreamMappingMethod (non-enum / non-value mapping)
Nouns	Class taking care of Noun manipulation
NullPresenceCheck
NullValueCheckStrategy	Strategy for dealing with null source values.
NullValueMappingStrategy	Strategy for dealing with null values passed to mapping methods.
NullValuePropertyMappingStrategy	Strategy for dealing with null or not present properties in the source bean.
ObjectFactory	This annotation marks a method as a factory method to create beans.
ObjectFactoryMethodResolver
Options	The options passed to the code generator.
Parameter	A parameter of a mapping method.
ParameterBinding	Represents how one parameter of a method to be called is populated.
ParameterElementAccessor	An Accessor that wraps a VariableElement.
ParameterProvidedMethods	Provides access to the SourceMethods that are provided by Context parameters of a Method and maintains the relationship between those methods and their originating parameter.
ParameterProvidedMethods.Builder
PrefixEnumTransformationStrategy
PresenceCheck	Marker interface for presence checks.
PresenceCheckAccessor
PresenceCheckMethodResolver
PrimitiveToPrimitiveConversion	Conversion between primitive types such as byte or long.
PrimitiveToStringConversion	Conversion between primitive types such as byte or long and String.
PrimitiveToWrapperConversion	Conversion between primitive types such as byte and wrapper types such as Integer.
PropertyEntry	A PropertyEntry contains information on the name, readAccessor and presenceCheck (for source) and return type of property.
PropertyMapping	Represents the mapping between a source and target property, e.g. from String Source#foo to int Target#bar.
PropertyMapping.ConstantMappingBuilder
PropertyMapping.JavaExpressionMappingBuilder
PropertyMapping.PropertyMappingBuilder
Qualifier	Declares an annotation type to be a qualifier.
QualifierSelector	This selector selects a best match based on qualifier annotations.
ReadAccessor
ReadDelegateAccessor
RecordElementAccessor	An Accessor that wraps a VariableElement.
RepeatableAnnotations<SINGULAR extends org.mapstruct.tools.gem.Gem,MULTIPLE extends org.mapstruct.tools.gem.Gem,OPTIONS>
ReportingPolicy	Policy for reporting issues occurring during the generation of a mapper implementation.
ReturnWrapper	Decorates an assignment as a return variable.
ReverseConversion	* A ConversionProvider which creates the inversed conversions for a given conversion provider.
RoundContext	Keeps contextual data in the scope of one annotation processing round.
SelectedMethod<T extends Method>	A selected method with additional metadata that might be required for further usage of the selected method.
SelectionContext	Context passed to the selectors to get the information they need.
SelectionCriteria	This class groups the selection criteria in one class
SelectionCriteria.Type
SelectionParameters	Holding parameters common to the selection process, common to IterableMapping, BeanMapping, PropertyMapping and MapMapping
Services	A simple locator for SPI implementations.
ServicesEntry
SetterWrapper	Wraps the assignment in a target setter.
SetterWrapperForCollectionsAndMaps	This wrapper handles the situation where an assignment is done via the setter, without doing anything special.
SetterWrapperForCollectionsAndMapsWithNullCheck	This wrapper handles the situation where an assignment is done via the setter and a null check is needed.
SimpleConversion	Base class for ConversionProviders creating TypeConversions which don't declare any exception types.
SourceMethod	Represents a mapping method with source and target type and the mappings between the properties of source and target type.
SourceMethod.Builder
SourceParameterCondition	This annotation marks a method as a check method to check if a source parameter needs to be mapped.
SourcePropertyName	This annotation marks a presence check method parameter as a source property name parameter.
SourceReference	This class describes the source side of a property mapping.
SourceReference.BuilderFromMapping	Builds a SourceReference from an @Mappping.
SourceReference.BuilderFromProperty	Builds a SourceReference from a property.
SourceReference.BuilderFromSourceReference	Builds a SourceReference from a property.
SourceRHS	SourceRHS Assignment.
SourceRhsSelector	Selector that tries to resolve an ambiquity between methods that contain source parameters and SourceRHS type parameters.
SpringComponentProcessor	A ModelElementProcessor which converts the given Mapper object into a Spring bean in case Spring is configured as the target component model for this mapper.
StaticParseToStringConversion	Handles conversion between a target type T and String, where T#parse(String) and T#toString are inverse operations.
StreamAdderWrapper	Wraps the assignment in a target setter.
StreamMappingMethod	A MappingMethod implemented by a Mapper class which maps one iterable or array type to Stream.
StreamMappingMethod.Builder
StringBuilderToStringConversion	Handles conversion between a target type StringBuilder and String.
Strings	Helper class for dealing with strings.
StringToXmlGregorianCalendar
StripPrefixEnumTransformationStrategy
StripSuffixEnumTransformationStrategy
SubclassExhaustiveStrategy	Strategy for dealing with subclassMapping annotated methods.
SubclassMapping	Represents the mapping between a Subclass and its mapping target.
SubclassMapping	Configures the mapping to handle hierarchy of the source type.
SubclassMappingOptions	Represents a subclass mapping as configured via @SubclassMapping.
SubclassMappings	Configures the SubclassMappings of several subclasses.
SubclassValidator	Handles the validation of multiple @SubclassMapping annotations on the same method.
SuffixEnumTransformationStrategy
SuffixPresenceCheck
SupportingConstructorFragment	A mapper instance field, initialized as null
SupportingField	supports the
SupportingMappingMethod	A mapping method which is not based on an actual method declared in the original mapper interface but is added as private method to map a certain source/target type combination.
TargetPropertyName	This annotation marks a presence check method parameter as a target property name parameter.
TargetReference	This class describes the target side of a property mapping.
TargetReference.Builder	Builds a TargetReference from an @Mappping.
TargetType	Declares a parameter of a custom mapping method to be populated with the target type of the mapping.
TargetTypeSelector	This selector selects a best match based on the result type.
Type	Represents (a reference to) the type of a bean property, parameter etc.
Type.ResolvedPair	Reflects any Resolved Pair, examples are T, String ?
TypeConversion	An inline conversion between source and target type of a mapping.
TypeFactory	Factory creating Type instances.
TypeHierarchyErroneousException	Indicates a type was visited whose hierarchy was erroneous, because it has a non-existing super-type.
TypeSelector	Selects those methods from the given input set which match the given source and target types (via MethodMatcher).
TypeUtils
UpdateWrapper	Wraps the assignment in a target setter.
URLToStringConversion	Conversion between URL and String.
UUIDToStringConversion	Conversion between UUID and String.
ValueMapping	Configures the mapping of source constant value to target constant value.
ValueMappingMethod	A ValueMappingMethod which maps one value type to another, optionally configured by one or more ValueMappingOptionss.
ValueMappingMethod.Builder
ValueMappingMethod.MappingEntry
ValueMappingOptions	Represents the mapping between one value constant and another.
ValueMappings	Constructs a set of value (constant) mappings.
VersionInformation	Provides information about the processor version and the processor context implementation version
WrapperForCollectionsAndMaps	This is the base class for the GetterWrapperForCollectionsAndMaps and SetterWrapperForCollectionsAndMaps
WrapperToStringConversion	Conversion between wrapper types such as Integer and String.
WrapperToWrapperConversion	Conversion between wrapper types such as Integer or Long.
Writable	An element with the ability to write itself into a given Writer.
Writable.Context	Passed to Writable, providing access to additional data specific to a given implementation of the model serialization mechanism.
XmlConstants	Helper holding JAXB time full qualified class names for conversion registration
XmlGregorianCalendarToCalendar
XmlGregorianCalendarToDate
XmlGregorianCalendarToJodaDateTime
XmlGregorianCalendarToJodaLocalDate
XmlGregorianCalendarToJodaLocalDateTime
XmlGregorianCalendarToJodaLocalTime
XmlGregorianCalendarToLocalDate
XmlGregorianCalendarToLocalDateTime
XmlGregorianCalendarToString
ZonedDateTimeToCalendar	BuiltInMethod for mapping between Calendar and ZonedDateTime.
ZonedDateTimeToXmlGregorianCalendar