All Classes

Class	Description
AbstractDeserializer	Deserializer only used for abstract types used as placeholders during polymorphic type handling deserialization.
AbstractTypeResolver	Defines interface for resolvers that can resolve abstract types into concrete ones; either by using static mappings, or possibly by materializing implementations dynamically.
AccessorNamingStrategy	API for handlers used to "mangle" names of "getter" and "setter" methods to find implicit property names.
AccessorNamingStrategy.Base	Helper class that implements all abstract methods with dummy implementations.
AccessorNamingStrategy.Provider	Interface for provider (factory) for constructing AccessorNamingStrategy for given type of deserialization target
AccessPattern	Enumeration used to indicate required access pattern for providers: this can sometimes be used to optimize out dynamic calls.
Annotated	Shared base class used for anything on which annotations (included within a AnnotationMap).
AnnotatedAndMetadata<A extends Annotated,M>	Silly little "Pair" class needed for 2-element tuples (without adding dependency to one of 3rd party packages that has one).
AnnotatedClass
AnnotatedClass.Creators
AnnotatedClassResolver	Helper class that contains logic for resolving annotations to construct AnnotatedClass instances.
AnnotatedConstructor
AnnotatedField	Object that represents non-static (and usually non-transient/volatile) fields of a class.
AnnotatedFieldCollector
AnnotatedMember	Intermediate base class for annotated entities that are members of a class; fields, methods and constructors.
AnnotatedMethod
AnnotatedMethodCollector
AnnotatedMethodMap	Simple helper class used to keep track of collection of AnnotatedMethods, accessible by lookup.
AnnotatedParameter	Object that represents method parameters, mostly so that associated annotations can be processed conveniently.
AnnotatedWithParams	Intermediate base class that encapsulates features that constructors and methods share.
AnnotationCollector	Helper class used to collect annotations to be stored as Annotations (like AnnotationMap).
AnnotationCollector.NoAnnotations	Immutable implementation for case where no annotations are associated with an annotatable entity.
AnnotationCollector.OneAnnotation
AnnotationCollector.TwoAnnotations
AnnotationIntrospector	Abstract class that defines API used for introspecting annotation-based configuration for serialization and deserialization.
AnnotationIntrospector.ReferenceProperty	Value type used with managed and back references; contains type and logic name, used to link related references
AnnotationIntrospector.ReferenceProperty.Type
AnnotationIntrospector.XmlExtensions	Add-on extension used for XML-specific configuration, needed to decouple format module functionality from pluggable introspection functionality (especially JAXB-annotation related one).
AnnotationIntrospectorPair	Helper class that allows using 2 introspectors such that one introspector acts as the primary one to use; and second one as a fallback used if the primary does not provide conclusive or useful result for a method.
AnnotationMap	Simple helper class used to keep track of collection of Jackson Annotations associated with annotatable things (methods, constructors, classes).
Annotations	Interface that defines interface for accessing contents of a collection of annotations.
AnyGetterWriter	Class similar to BeanPropertyWriter, but that will be used for serializing JsonAnyGetter annotated (Map) properties
ArrayBlockingQueueDeserializer	We need a custom deserializer both because ArrayBlockingQueue has no default constructor AND because it has size limit used for constructing underlying storage automatically.
ArrayBuilders	Helper class that contains set of distinct builders for different arrays of primitive values.
ArrayBuilders.BooleanBuilder
ArrayBuilders.ByteBuilder
ArrayBuilders.DoubleBuilder
ArrayBuilders.FloatBuilder
ArrayBuilders.IntBuilder
ArrayBuilders.LongBuilder
ArrayBuilders.ShortBuilder
ArrayIterator<T>	Iterator implementation used to efficiently expose contents of an Array as read-only iterator.
ArrayNode	Node class that represents Arrays mapped from JSON content.
ArraySerializerBase<T>	Intermediate base class for serializers used for various Java arrays.
ArrayType	Array types represent Java arrays, both primitive and object valued.
AsArraySerializerBase<T>	Base class for serializers that will output contents as JSON arrays; typically serializers used for Collection and array types.
AsArrayTypeDeserializer	Type deserializer used with JsonTypeInfo.As.WRAPPER_ARRAY inclusion mechanism.
AsArrayTypeSerializer	Type serializer that will embed type information in an array, as the first element, and actual value as the second element.
AsDeductionTypeDeserializer	A TypeDeserializer capable of deducing polymorphic types based on the fields available.
AsExistingPropertyTypeSerializer	Type serializer used with JsonTypeInfo.As.EXISTING_PROPERTY inclusion mechanism.
AsExternalTypeDeserializer	Type deserializer used with JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.
AsExternalTypeSerializer	Type serializer that preferably embeds type information as an "external" type property; embedded in enclosing JSON object.
AsPropertyTypeDeserializer	Type deserializer used with JsonTypeInfo.As.PROPERTY inclusion mechanism.
AsPropertyTypeSerializer	Type serializer that preferably embeds type information as an additional JSON Object property, if possible (when resulting serialization would use JSON Object).
AsWrapperTypeDeserializer	Type deserializer used with JsonTypeInfo.As.WRAPPER_OBJECT inclusion mechanism.
AsWrapperTypeSerializer	Type wrapper that tries to use an extra JSON Object, with a single entry that has type name as key, to serialize type information.
AtomicBooleanDeserializer
AtomicIntegerDeserializer
AtomicLongDeserializer
AtomicReferenceDeserializer
AtomicReferenceSerializer
AttributePropertyWriter	VirtualBeanPropertyWriter implementation used for JsonAppend, to serialize properties backed-by dynamically assignable attribute values.
BaseJsonNode	Abstract base class common to all standard JsonNode implementations.
BaseSettings	Immutable container class used to store simple configuration settings for both serialization and deserialization.
BasicBeanDescription	Default BeanDescription implementation used by Jackson.
BasicClassIntrospector
BasicDeserializerFactory	Abstract factory base class that can provide deserializers for standard JDK classes, including collection classes and simple heuristics for "upcasting" common collection interface types (such as Collection).
BasicDeserializerFactory.ContainerDefaultMappings	Helper class to contain default mappings for abstract JDK Collection and Map types.
BasicDeserializerFactory.CreatorCollectionState	Helper class to contain largish number of parameters that need to be passed during Creator introspection.
BasicPolymorphicTypeValidator	Standard BasicPolymorphicTypeValidator implementation that users may want to use for constructing validators based on simple class hierarchy and/or name patterns to allow and/or deny certain subtypes.
BasicPolymorphicTypeValidator.Builder	Builder class for configuring and constructing immutable BasicPolymorphicTypeValidator instances.
BasicPolymorphicTypeValidator.NameMatcher	General matcher interface (predicate) for validating unresolved subclass class name.
BasicPolymorphicTypeValidator.TypeMatcher	General matcher interface (predicate) for validating class values (base type or resolved subtype)
BasicSerializerFactory	Factory class that can provide serializers for standard JDK classes, as well as custom classes that extend standard classes or implement one of "well-known" interfaces (such as Collection).
BeanAsArrayBuilderDeserializer
BeanAsArrayDeserializer	Variant of BeanDeserializer used for handling deserialization of POJOs when serialized as JSON Arrays, instead of JSON Objects.
BeanAsArraySerializer	Specialized POJO serializer that differs from BeanSerializer in that instead of producing a JSON Object it will output a JSON Array, omitting field names, and serializing values in specified serialization order.
BeanDescription	Basic container for information gathered by ClassIntrospector to help in constructing serializers and deserializers.
BeanDeserializer	Deserializer class that can deserialize instances of arbitrary bean objects, usually from JSON Object structs,
BeanDeserializerBase	Base class for BeanDeserializer.
BeanDeserializerBuilder	Builder class used for aggregating deserialization information about a POJO, in order to build a JsonDeserializer for deserializing instances.
BeanDeserializerFactory	Concrete deserializer factory class that adds full Bean deserializer construction logic using class introspection.
BeanDeserializerModifier	Abstract class that defines API for objects that can be registered to participate in constructing JsonDeserializer instances (via DeserializerFactory).
BeanProperty	Bean properties are logical entities that represent data that Java objects (POJOs (Plain Old Java Objects), sometimes also called "beans") contain; and that are accessed using accessors (methods like getters and setters, fields, constructor parameters).
BeanProperty.Bogus	Alternative "Null" implementation that can be used in cases where a non-null BeanProperty is needed
BeanProperty.Std	Simple stand-alone implementation, useful as a placeholder or base class for more complex implementations.
BeanPropertyDefinition	Simple value classes that contain definitions of properties, used during introspection of properties to use for serialization and deserialization purposes.
BeanPropertyFilter	Deprecated. Since 2.3: use PropertyFilter instead.
BeanPropertyMap	Helper class used for storing mapping from property name to SettableBeanProperty instances.
BeanPropertyWriter	Base bean property handler class, which implements common parts of reflection-based functionality for accessing a property value and serializing it.
BeanSerializer	Serializer class that can serialize Java objects that map to JSON Object output.
BeanSerializerBase	Base class both for the standard bean serializer, and couple of variants that only differ in small details.
BeanSerializerBuilder	Builder class used for aggregating deserialization information about a POJO, in order to build a JsonSerializer for serializing intances.
BeanSerializerFactory	Factory class that can provide serializers for any regular Java beans (as defined by "having at least one get method recognizable as bean accessor" -- where Object.getClass() does not count); as well as for "standard" JDK types.
BeanSerializerModifier	Abstract class that defines API for objects that can be registered (for BeanSerializerFactory to participate in constructing BeanSerializer instances.
BeanUtil	Helper class that contains functionality needed by both serialization and deserialization side.
BigIntegerNode	Numeric node that contains simple 64-bit integer values.
BinaryNode	Value node that contains Base64 encoded binary value, which will be output and stored as Json String value.
BooleanNode	This concrete value class is used to contain boolean (true / false) values.
BooleanSerializer	Serializer used for primitive boolean, as well as java.util.Boolean wrapper type.
BuilderBasedDeserializer	Class that handles deserialization using a separate Builder class, which is used for data binding and produces actual deserialized value at the end of data binding.
ByteArraySerializer	Unlike other integral number array serializers, we do not just print out byte values as numbers.
ByteBufferBackedInputStream	Simple InputStream implementation that exposes currently available content of a ByteBuffer.
ByteBufferBackedOutputStream	Simple OutputStream implementation that appends content written in given ByteBuffer instance.
ByteBufferDeserializer
ByteBufferSerializer
CalendarSerializer	Standard serializer for Calendar.
ClassIntrospector	Helper class used to introspect features of POJO value classes used with Jackson.
ClassIntrospector.MixInResolver	Interface used for decoupling details of how mix-in annotation definitions are accessed (via this interface), and how they are stored (defined by classes that implement the interface)
ClassKey	Key class, used as an efficient and accurate key for locating per-class values, such as JsonSerializers.
ClassNameIdResolver	TypeIdResolver implementation that converts between fully-qualified Java class names and (JSON) Strings.
ClassSerializer	Also: default bean access will not do much good with Class.class.
ClassStack	Simple helper class used to keep track of 'call stack' for classes being referenced (as well as unbound variables)
ClassUtil
ClassUtil.Ctor	Value class used for caching Constructor declarations; used because caching done by JDK appears to be somewhat inefficient for some use cases.
CoercionAction	Set of possible actions for requested coercion from an input shape CoercionInputShape that does not directly or naturally match target type (LogicalType).
CoercionConfig
CoercionConfigs
CoercionInputShape	Set of input types (which mostly match one of JsonToken types) used for configuring CoercionActions to take when reading input into target types (specific type or LogicalType).
CollectionDeserializer	Basic serializer that can take JSON "Array" structure and construct a Collection instance, with typed contents.
CollectionDeserializer.CollectionReferringAccumulator	Helper class for dealing with Object Id references for values contained in collections being deserialized.
CollectionLikeType	Type that represents things that act similar to Collection; but may or may not be instances of that interface.
CollectionSerializer	Fallback serializer for cases where Collection is not known to be of type for which more specializer serializer exists (such as index-accessible List).
CollectionType	Type that represents Java Collection types (Lists, Sets).
CompactStringObjectMap	Specialized lookup class that implements functionality similar to Map, but for special case of key always being String and using more compact (and memory-access friendly) hashing scheme.
ConcreteBeanPropertyBase	Intermediate BeanProperty class shared by concrete readable- and writable property implementations for sharing common functionality.
ConfigFeature	Interface that actual SerializationFeature enumerations used by MapperConfig implementations must implement.
ConfigOverride	Configuration object that is accessed by databinding functionality to find overrides to configuration of properties, based on declared type of the property.
ConfigOverrides	Container for individual ConfigOverride values.
ConstructorDetector	Configurable handler used to select aspects of selecting constructor to use as "Creator" for POJOs.
ConstructorDetector.SingleArgConstructor	Definition of alternate handling modes of single-argument constructors that are annotated with JsonCreator but without "mode" definition (or explicit name for the argument): this is the case where two interpretations are possible -- "properties" (in which case the argument is named parameter of a JSON Object) and "delegating (in which case the argument maps to the whole JSON value).
ContainerDeserializerBase<T>	Intermediate base deserializer class that adds more shared accessor so that other classes can access information about contained (value) types
ContainerNode<T extends ContainerNode<T>>	This intermediate base class is used for all container nodes, specifically, array and object nodes.
ContainerSerializer<T>	Intermediate base class for serializers used for serializing types that contain element(s) of other types, such as arrays, Collections (Lists, Sets etc) and Maps and iterable things (Iterators).
ContextAttributes	Helper class used for storing and accessing per-call attributes.
ContextAttributes.Impl
ContextualDeserializer	Add-on interface that JsonDeserializers can implement to get a callback that can be used to create contextual (context-dependent) instances of deserializer to use for handling properties of supported type.
ContextualKeyDeserializer	Add-on interface that KeyDeserializers can implement to get a callback that can be used to create contextual instances of key deserializer to use for handling Map keys of supported type.
ContextualSerializer	Add-on interface that JsonSerializers can implement to get a callback that can be used to create contextual instances of serializer to use for handling properties of supported type.
Converter<IN,OUT>	Helper interface for things that convert Objects of one type to another.
Converter.None	This marker class is only to be used with annotations, to indicate that no converter is to be used.
CoreXMLDeserializers	Container deserializers that handle "core" XML types: ones included in standard JDK 1.5.
CoreXMLDeserializers.Std	Combo-deserializer that supports deserialization of somewhat optional javax.xml types QName, Duration and XMLGregorianCalendar.
CoreXMLSerializers	Provider for serializers of XML types that are part of full JDK 1.5, but that some alleged 1.5 platforms are missing (Android, GAE).
CoreXMLSerializers.XMLGregorianCalendarSerializer
CreatorCandidate
CreatorCandidate.Param
CreatorCollector	Container class for storing information on creators (based on annotations, visibility), to be able to build actual ValueInstantiator later on.
CreatorProperty	This concrete sub-class implements property that is passed via Creator (constructor or static factory method).
DatabindContext	Shared base class for DeserializationContext and SerializerProvider, context objects passed through data-binding process.
DatabindException	Intermediate base class for all databind level processing problems, as distinct from stream-level problems or I/O issues below.
DataFormatReaders	Alternative to DataFormatDetector that needs to be used when using data-binding.
DataFormatReaders.AccessorForReader	We need sub-class here as well, to be able to access efficiently.
DataFormatReaders.Match	Result class, similar to DataFormatMatcher
DateDeserializers	Container class for core JDK date/time type deserializers.
DateDeserializers.CalendarDeserializer
DateDeserializers.DateBasedDeserializer<T>
DateDeserializers.DateDeserializer	Simple deserializer for handling Date values.
DateDeserializers.SqlDateDeserializer	Compared to plain old Date, SQL version is easier to deal with: mostly because it is more limited.
DateDeserializers.TimestampDeserializer	Simple deserializer for handling Timestamp values.
DateSerializer	For efficiency, we will serialize Dates as longs, instead of potentially more readable Strings.
DateTimeSerializerBase<T>
DecimalNode	Numeric node that contains values that do not fit in simple integer (int, long) or floating point (double) values.
DefaultAccessorNamingStrategy	Default AccessorNamingStrategy used by Jackson: to be used either as-is, or as base-class with overrides.
DefaultAccessorNamingStrategy.BaseNameValidator	Definition of a handler API to use for checking whether given base name (remainder of accessor method name after removing prefix) is acceptable based on various rules.
DefaultAccessorNamingStrategy.FirstCharBasedValidator	Simple implementation of DefaultAccessorNamingStrategy.BaseNameValidator that checks the first character and nothing else.
DefaultAccessorNamingStrategy.Provider	Provider for DefaultAccessorNamingStrategy.
DefaultAccessorNamingStrategy.RecordNaming	Implementation used for supporting "non-prefix" naming convention of Java 14 java.lang.Record types, and in particular find default accessors for declared record fields.
DefaultBaseTypeLimitingValidator	PolymorphicTypeValidator that will only allow polymorphic handling if the base type is NOT one of potential dangerous base types (see DefaultBaseTypeLimitingValidator.isUnsafeBaseType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.JavaType) for specific list of such base types).
DefaultDeserializationContext	Complete DeserializationContext implementation that adds extended API for ObjectMapper (and ObjectReader) to call, as well as implements certain parts that base class has left abstract.
DefaultDeserializationContext.Impl	Actual full concrete implementation
DefaultSerializerProvider	Standard implementation used by ObjectMapper: adds methods only exposed to ObjectMapper, as well as constructors.
DefaultSerializerProvider.Impl	Concrete implementation that defines factory method(s), defined as final.
DelegatingDeserializer	Base class that simplifies implementations of JsonDeserializers that mostly delegate functionality to another deserializer implementation (possibly forming a chaing of deserializers delegating functionality in some cases)
DeserializationConfig	Object that contains baseline configuration for deserialization process.
DeserializationContext	Context for the process of deserialization a single root-level value.
DeserializationFeature	Enumeration that defines simple on/off features that affect the way Java objects are deserialized from JSON
DeserializationProblemHandler	This is the class that can be registered (via DeserializationConfig object owner by ObjectMapper) to get called when a potentially recoverable problem is encountered during deserialization process.
DeserializerCache	Class that defines caching layer between callers (like ObjectMapper, DeserializationContext) and classes that construct deserializers (DeserializerFactory).
DeserializerFactory	Abstract class that defines API used by DeserializationContext to construct actual JsonDeserializer instances (which are then cached by context and/or dedicated cache).
DeserializerFactoryConfig	Configuration settings container class for DeserializerFactory.
Deserializers	Interface that defines API for simple extensions that can provide additional deserializers for various types.
Deserializers.Base	Basic Deserializers implementation that implements all methods but provides no deserializers.
DOMDeserializer<T>	Base for serializers that allows parsing DOM Documents from JSON Strings.
DOMDeserializer.DocumentDeserializer
DOMDeserializer.NodeDeserializer
DOMSerializer
DoubleNode	Numeric node that contains 64-bit ("double precision") floating point values simple 32-bit integer values.
EnumDeserializer	Deserializer class that can deserialize instances of specified Enum class from Strings and Integers.
EnumMapDeserializer	Deserializer for EnumMap values.
EnumResolver	Helper class used to resolve String values (either JSON Object field names or regular String values) into Java Enum instances.
EnumSerializer	Standard serializer used for Enum types.
EnumSetDeserializer	Standard deserializer for EnumSets.
EnumSetSerializer
EnumValues	Helper class used for storing String serializations of Enums, to match to/from external representations.
ErrorThrowingDeserializer	A deserializer that stores an Error caught during constructing of the deserializer, which needs to be deferred and only during actual attempt to deserialize a value of given type.
ExternalTypeHandler	Helper class that is used to flatten JSON structure when using "external type id" (see JsonTypeInfo.As.EXTERNAL_PROPERTY).
ExternalTypeHandler.Builder
FailingDeserializer	Special bogus "serializer" that will throw MismatchedInputException if an attempt is made to deserialize a value.
FailingSerializer	Special bogus "serializer" that will throw JsonMappingException if its FailingSerializer.serialize(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) gets invoked.
FieldProperty	This concrete sub-class implements property that is set directly assigning to a Field.
FileSerializer	For now, File objects get serialized by just outputting absolute (but not canonical) name as String value
FilteredBeanPropertyWriter	Decorated BeanPropertyWriter that will filter out properties that are not to be included in currently active JsonView.
FilterProvider	Interface for objects that providers instances of PropertyFilter that match given ids.
FloatNode	JsonNode implementation for efficiently containing 32-bit `float` values.
FromStringDeserializer<T>	Base class for simple deserializers that serialize values from String representation: this includes JSON Strings and other Scalar values that can be coerced into text, like Numbers and Booleans).
FromStringDeserializer.Std	"Chameleon" deserializer that works on simple types that are deserialized from a simple String.
HandlerInstantiator	Helper class used for handling details of creating handler instances (things like JsonSerializers, JsonDeserializers, various type handlers) of specific types.
IgnoredPropertyException	Specialized JsonMappingException sub-class used to indicate case where an explicitly ignored property is encountered, and mapper is configured to consider this an error.
IgnorePropertiesUtil
IgnorePropertiesUtil.Checker	Helper class to encapsulate logic from static shouldIgnore method of util class.
IndexedListSerializer	This is an optimized serializer for Lists that can be efficiently traversed by index (as opposed to others, such as LinkedList that cannot}.
IndexedStringListSerializer	Efficient implement for serializing Lists that contains Strings and are random-accessible.
InetAddressSerializer	Simple serializer for InetAddress.
InetSocketAddressSerializer	Simple serializer for InetSocketAddress.
InjectableValues	Abstract class that defines API for objects that provide value to "inject" during deserialization.
InjectableValues.Std	Simple standard implementation which uses a simple Map to store values to inject, identified by simple String keys.
InnerClassProperty	This sub-class is used to handle special case of value being a non-static inner class.
IntNode	Numeric node that contains simple 32-bit integer values.
InvalidDefinitionException	Intermediate exception type used as the base class for all JsonMappingExceptions that are due to problems with target type definition; usually a problem with annotations used on a class or its properties.
InvalidFormatException	Specialized sub-class of MismatchedInputException that is used when the underlying problem appears to be that of bad formatting of a value to deserialize.
InvalidNullException	Exception thrown if a `null` value is being encountered for a property designed as "fail on null" property (see JsonSetter).
InvalidTypeIdException	Exception thrown when resolution of a type id fails.
ISO8601DateFormat	Deprecated. Use StdDateFormat instead
ISO8601Utils	Deprecated.
IterableSerializer
IteratorSerializer
JacksonAnnotationIntrospector	AnnotationIntrospector implementation that handles standard Jackson annotations.
JacksonStdImpl	Marker interface used to indicate implementation classes (serializers, deserializers etc) that are standard ones Jackson uses; not custom ones that application has added.
Java7Handlers	To support Java7-incomplete platforms, we will offer support for JDK 7 datatype(s) (that is, Path through this class, loaded dynamically; if loading fails, support will be missing.
Java7HandlersImpl
Java7Support	To support Java7-incomplete platforms, we will offer support for JDK 7 annotations through this class, loaded dynamically; if loading fails, support will be missing.
Java7SupportImpl
JavaType	Base class for type token classes used both to contain information and as keys for deserializers.
JavaUtilCollectionsDeserializers	Helper class used to contain logic for deserializing "special" containers from java.util.Collections and java.util.Arrays.
JDK14Util	Helper class to support some of JDK 14 (and later) features without Jackson itself being run on (or even built with) Java 14.
JdkDeserializers	Container class that contains serializers for JDK types that require special handling for some reason.
JDKValueInstantiators	Container for a set of ValueInstantiators used for certain critical JDK value types, either as performance optimization for initialization time observed by profiling, or due to difficulty in otherwise finding constructors.
JsonAnyFormatVisitor
JsonAnyFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonAppend	Annotation that may be used to add "virtual" properties to be written after regular properties (although ordering may be changed using both standard @JsonPropertyOrder annotation, and properties of this annotation).
JsonAppend.Attr	Definition of a single attribute-backed property.
JsonAppend.Prop	Definition of a single general virtual property.
JsonArrayFormatVisitor
JsonArrayFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonBooleanFormatVisitor
JsonBooleanFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonDeserialize	Annotation use for configuring deserialization aspects, by attaching to "setter" methods or fields, or to value classes.
JsonDeserializer<T>	Abstract class that defines API used by ObjectMapper (and other chained JsonDeserializers too) to deserialize Objects of arbitrary types from JSON, using provided JsonParser.
JsonDeserializer.None	This marker class is only to be used with annotations, to indicate that no deserializer is configured.
JsonFormatTypes
JsonFormatVisitable	Interface JsonSerializer implements to allow for visiting type hierarchy.
JsonFormatVisitorWithSerializerProvider
JsonFormatVisitorWrapper	Interface for visitor callbacks, when type in question can be any of legal JSON types.
JsonFormatVisitorWrapper.Base	Empty "no-op" implementation of JsonFormatVisitorWrapper, suitable for sub-classing.
JsonIntegerFormatVisitor
JsonIntegerFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonLocationInstantiator	For JsonLocation, we should be able to just implement ValueInstantiator (not that explicit one would be very hard but...)
JsonMapFormatVisitor
JsonMapFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonMapper	JSON-format specific ObjectMapper implementation.
JsonMapper.Builder	Base implementation for "Vanilla" ObjectMapper, used with JSON dataformat backend.
JsonMappingException	Checked exception used to signal fatal problems with mapping of content, distinct from low-level I/O problems (signaled using simple IOExceptions) or data encoding/decoding problems (signaled with StreamReadException, StreamWriteException).
JsonMappingException.Reference	Simple bean class used to contain references.
JsonNaming	Annotation that can be used to indicate a PropertyNamingStrategy to use for annotated class.
JsonNode	Base class for all JSON nodes, which form the basis of JSON Tree Model that Jackson implements.
JsonNodeCreator	Interface that defines common "creator" functionality implemented both by JsonNodeFactory and ContainerNode (that is, JSON Object and Array nodes).
JsonNodeDeserializer	Deserializer that can build instances of JsonNode from any JSON content, using appropriate JsonNode type.
JsonNodeFactory	Base class that specifies methods for getting access to Node instances (newly constructed, or shared, depending on type), as well as basic implementation of the methods.
JsonNodeType	Enumeration of JSON types.
JsonNullFormatVisitor
JsonNullFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonNumberFormatVisitor
JsonNumberFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonObjectFormatVisitor	Visitor called when properties of a type that maps to JSON Object are being visited: this usually means POJOs, but sometimes other types use it too (like EnumMap).
JsonObjectFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JSONPObject	Container class that can be used to wrap any Object instances (including nulls), and will serialize embedded in JSONP wrapping.
JsonPOJOBuilder	Annotation used to configure details of a Builder class: instances of which are used as Builders for deserialized POJO values, instead of POJOs being instantiated using constructors or factory methods.
JsonPOJOBuilder.Value	Simple value container for containing values read from JsonPOJOBuilder annotation instance.
JsonSchema	Deprecated. Since 2.2, we recommend use of external JSON Schema generator module
JsonSerializable	Interface that can be implemented by objects that know how to serialize themselves to JSON, using JsonGenerator (and SerializerProvider if necessary).
JsonSerializable.Base	Base class with minimal implementation, as well as couple of extension methods that core Jackson databinding makes use of.
JsonSerializableSchema	Annotation that can be used to define JSON Schema definition for the annotated class.
JsonSerialize	Annotation used for configuring serialization aspects, by attaching to "getter" methods or fields, or to value classes.
JsonSerialize.Inclusion	Deprecated.
JsonSerialize.Typing	Enumeration used with JsonSerialize.typing() property to define whether type detection is based on dynamic runtime type (DYNAMIC) or declared type (STATIC).
JsonSerializer<T>	Abstract class that defines API used by ObjectMapper (and other chained JsonSerializers too) to serialize Objects of arbitrary types into JSON, using provided JsonGenerator.
JsonSerializer.None	This marker class is only to be used with annotations, to indicate that no serializer is configured.
JsonStringFormatVisitor
JsonStringFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonTypeIdResolver	Annotation that can be used to plug a custom type identifier handler (TypeIdResolver) to be used by TypeSerializers and TypeDeserializers for converting between java types and type id included in JSON content.
JsonTypeResolver	Annotation that can be used to explicitly define custom resolver used for handling serialization and deserialization of type information, needed for handling of polymorphic types (or sometimes just for linking abstract types to concrete types)
JsonValueFormat	This enum represents the encoded format for a jsonSchema value type
JsonValueFormatVisitor
JsonValueFormatVisitor.Base	Default "empty" implementation, useful as the base to start on; especially as it is guaranteed to implement all the method of the interface, even if new methods are getting added.
JsonValueInstantiator	Annotation that can be used to indicate a ValueInstantiator to use for creating instances of specified type.
JsonValueSerializer	Serializer class that can serialize Object that have a JsonValue annotation to indicate that serialization should be done by calling the method annotated, and serializing result it returns.
JSONWrappedObject	General-purpose wrapper class that can be used to decorate serialized value with arbitrary literal prefix and suffix.
KeyDeserializer	Abstract class that defines API used for deserializing JSON content field names into Java Map keys.
KeyDeserializer.None	This marker class is only to be used with annotations, to indicate that no deserializer is configured.
KeyDeserializers	Interface that defines API for simple extensions that can provide additional deserializers for deserializer Map keys of various types, from JSON property names.
LaissezFaireSubTypeValidator	Default PolymorphicTypeValidator used unless explicit one is constructed (and, in 2.11, MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES not enabled).
LinkedNode<T>	Node of a forward-only linked list.
LogicalType	Set of logical types (or type categories, classes of classes), used for defining applicability of configuration like coercion configuration.
LongNode	Numeric node that contains simple 64-bit integer values.
LookupCache<K,V>	An interface describing the required API for the Jackson-databind Type cache.
LRUMap<K,V>	Helper for simple bounded maps used for reusing lookup values.
ManagedReferenceProperty	Wrapper property that is used to handle managed (forward) properties Basically just needs to delegate first to actual forward property, and then to back property.
MapDeserializer	Basic deserializer that can take JSON "Object" structure and construct a Map instance, with typed contents.
MapEntryDeserializer	Basic serializer that can take JSON "Object" structure and construct a Map instance, with typed contents.
MapEntrySerializer
MapLikeType	Type that represents Map-like types; things that consist of key/value pairs but that do not necessarily implement Map, but that do not have enough introspection functionality to allow for some level of generic handling.
MapperBuilder<M extends ObjectMapper,B extends MapperBuilder<M,B>>	Jackson 3 will introduce fully immutable, builder-based system for constructing ObjectMappers.
MapperConfig<T extends MapperConfig<T>>	Interface that defines functionality accessible through both serialization and deserialization configuration objects; accessors to mode-independent configuration settings and such.
MapperConfigBase<CFG extends ConfigFeature,T extends MapperConfigBase<CFG,T>>
MapperFeature	Enumeration that defines simple on/off features to set for ObjectMapper, and accessible (but not changeable) via ObjectReader and ObjectWriter (as well as through various convenience methods through context objects).
MappingIterator<T>	Iterator exposed by ObjectMapper when binding sequence of objects.
MappingJsonFactory	Sub-class of JsonFactory that will create a proper ObjectCodec to allow seam-less conversions between JSON content and Java objects (POJOs).
MapProperty	Helper class needed to support flexible filtering of Map properties with generic JSON Filter functionality.
MapSerializer	Standard serializer implementation for serializing {link java.util.Map} types.
MapType	Type that represents "true" Java Map types.
MemberKey	Helper class needed to be able to efficiently access class member functions (Methods and Constructors) in Maps.
MergingSettableBeanProperty	SettableBeanProperty implementation that will try to access value of the property first, and if non-null value found, pass that for update (using JsonDeserializer.deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext, Object)) instead of constructing a new value.
MethodProperty	This concrete sub-class implements property that is set using regular "setter" method.
MinimalClassNameIdResolver
MismatchedInputException	General exception type used as the base class for all JsonMappingExceptions that are due to input not mapping to target definition; these are typically considered "client errors" since target type definition itself is not the root cause but mismatching input.
MissingNode	This singleton node class is generated to denote "missing nodes" along paths that do not exist.
Module	Simple interface for extensions that can be registered with ObjectMapper to provide a well-defined set of extensions to default functionality; such as support for new data types.
Module.SetupContext	Interface Jackson exposes to modules for purpose of registering extended functionality.
MutableCoercionConfig	Mutable version of CoercionConfig (or rather, extended API) exposed during configuration phase of ObjectMapper construction (via Builder).
MutableConfigOverride	Extension of ConfigOverride that allows changing of contained configuration settings.
Named	Simple tag interface mostly to allow sorting by name.
NamedType	Simple container class for types with optional logical name, used as external identifier
NameTransformer	Helper class used to encapsulate details of name mangling, transforming of names using different strategies (prefixes, suffixes).
NameTransformer.Chained
NameTransformer.NopTransformer
NioPathDeserializer
NioPathSerializer
NoClass	Marker class used with annotations to indicate "no class".
NonTypedScalarSerializerBase<T>	Deprecated.
NopAnnotationIntrospector	Dummy, "no-operation" implementation of AnnotationIntrospector.
NullifyingDeserializer	Bogus deserializer that will simply skip all content there is to map and returns Java null reference.
NullNode	This singleton value class is used to contain explicit JSON null value.
NullsAsEmptyProvider	Simple NullValueProvider that will always throw a InvalidNullException when a null is encountered.
NullsConstantProvider	Simple NullValueProvider that will always throw a InvalidNullException when a null is encountered.
NullSerializer	This is a simple dummy serializer that will just output literal JSON null value whenever serialization is requested.
NullsFailProvider	Simple NullValueProvider that will always throw a InvalidNullException when a null is encountered.
NullValueProvider	Helper interface implemented by classes that are to be used as null providers during deserialization.
NumberDeserializers	Container class for deserializers that handle core JDK primitive (and matching wrapper) types, as well as standard "big" numeric types.
NumberDeserializers.BigDecimalDeserializer
NumberDeserializers.BigIntegerDeserializer	This is bit trickier to implement efficiently, while avoiding overflow problems.
NumberDeserializers.BooleanDeserializer
NumberDeserializers.ByteDeserializer
NumberDeserializers.CharacterDeserializer
NumberDeserializers.DoubleDeserializer
NumberDeserializers.FloatDeserializer
NumberDeserializers.IntegerDeserializer
NumberDeserializers.LongDeserializer
NumberDeserializers.NumberDeserializer	For type Number.class, we can just rely on type mappings that plain JsonParser.getNumberValue() returns.
NumberDeserializers.PrimitiveOrWrapperDeserializer<T>
NumberDeserializers.ShortDeserializer
NumberSerializer	As a fallback, we may need to use this serializer for other types of Numbers: both custom types and "big" numbers like BigInteger and BigDecimal.
NumberSerializers	Container class for serializers used for handling standard JDK-provided primitve number types and their wrapper counterparts (like Integer).
NumberSerializers.Base<T>	Shared base class for actual primitive/wrapper number serializers.
NumberSerializers.DoubleSerializer	This is the special serializer for regular Doubles (and primitive doubles)
NumberSerializers.FloatSerializer
NumberSerializers.IntegerSerializer	This is the special serializer for regular Integers (and primitive ints)
NumberSerializers.IntLikeSerializer	Similar to NumberSerializers.IntegerSerializer, but will not cast to Integer: instead, cast is to Number, and conversion is by calling Number.intValue().
NumberSerializers.LongSerializer
NumberSerializers.ShortSerializer
NumericNode	Intermediate value node used for numeric nodes.
ObjectArrayDeserializer	Basic serializer that can serialize non-primitive arrays.
ObjectArraySerializer	Generic serializer for Object arrays (Object[]).
ObjectBuffer	Helper class to use for constructing Object arrays by appending entries to create arrays of various lengths (length that is not known a priori).
ObjectIdInfo	Container object that encapsulates information usually derived from JsonIdentityInfo annotation or its custom alternatives
ObjectIdReader	Object that knows how to deserialize Object Ids.
ObjectIdReferenceProperty
ObjectIdReferenceProperty.PropertyReferring
ObjectIdValueProperty	Specialized SettableBeanProperty implementation used for virtual property that represents Object Id that is used for some POJO types (or properties).
ObjectIdWriter	Object that knows how to serialize Object Ids.
ObjectMapper	ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Plain Old Java Objects), or to and from a general-purpose JSON Tree Model (JsonNode), as well as related functionality for performing conversions.
ObjectMapper.DefaultTypeResolverBuilder	Customized TypeResolverBuilder that provides type resolver builders used with so-called "default typing" (see ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) for details).
ObjectMapper.DefaultTyping	Enumeration used with ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) to specify what kind of types (classes) default typing should be used for.
ObjectNode	Node that maps to JSON Object structures in JSON content.
ObjectReader	Builder object that can be used for per-serialization configuration of deserialization parameters, such as root type to use or object to update (instead of constructing new instance).
ObjectWriter	Builder object that can be used for per-serialization configuration of serialization parameters, such as JSON View and root type to use.
ObjectWriter.GeneratorSettings	Helper class used for containing settings specifically related to (re)configuring JsonGenerator constructed for writing output.
ObjectWriter.Prefetch	As a minor optimization, we will make an effort to pre-fetch a serializer, or at least relevant TypeSerializer, if given enough information.
OptionalHandlerFactory	Helper class used for isolating details of handling optional+external types (javax.xml classes) from standard factories that offer them.
PackageVersion	Automatically generated from PackageVersion.java.in during packageVersion-generate execution of maven-replacer-plugin in pom.xml.
PlaceholderForType	Helper type used when introspecting bindings for already resolved types, needed for specialization.
POJONode	Value node that contains a wrapped POJO, to be serialized as a JSON constructed through data mapping (usually done by calling ObjectMapper).
POJOPropertiesCollector	Helper class used for aggregating information about all possible properties of a POJO.
POJOPropertyBuilder	Helper class used for aggregating information about a single potential POJO property.
POJOPropertyBuilder.Linked<T>	Node used for creating simple linked lists to efficiently store small sets of things.
POJOPropertyBuilder.MemberIterator<T extends AnnotatedMember>
PolymorphicTypeValidator	Interface for classes that handle validation of class-name - based subtypes used with Polymorphic Deserialization: both via "default typing" and explicit @JsonTypeInfo when using Java Class name as Type Identifier.
PolymorphicTypeValidator.Base	Shared base class with partial implementation (with all validation calls returning PolymorphicTypeValidator.Validity.INDETERMINATE) and convenience methods for indicating failure reasons.
PolymorphicTypeValidator.Validity	Definition of return values to indicate determination regarding validity.
PrimitiveArrayBuilder<T>	Base class for specialized primitive array builders.
PrimitiveArrayDeserializers<T>	Container for deserializers used for instantiating "primitive arrays", arrays that contain non-object java primitive types.
PropertyBasedCreator	Object that is used to collect arguments for non-default creator (non-default-constructor, or argument-taking factory method) before creator can be called.
PropertyBasedObjectIdGenerator
PropertyBasedObjectIdGenerator
PropertyBindingException	Base class for JsonMappingExceptions that are specifically related to problems related to binding an individual property.
PropertyBuilder	Helper class for BeanSerializerFactory that is used to construct BeanPropertyWriter instances.
PropertyFilter	Interface that defines API for filter objects use (as configured using JsonFilter) for filtering bean properties to serialize.
PropertyMetadata	Simple container class used for storing "additional" metadata about properties.
PropertyMetadata.MergeInfo	Helper class used for containing information about expected merge information for this property, if merging is expected.
PropertyName	Simple value class used for containing names of properties as defined by annotations (and possibly other configuration sources).
PropertyNamingStrategies	Container for standard PropertyNamingStrategy implementations and singleton instances.
PropertyNamingStrategies.KebabCaseStrategy	Naming strategy similar to PropertyNamingStrategies.SnakeCaseStrategy, but instead of underscores as separators, uses hyphens.
PropertyNamingStrategies.LowerCamelCaseStrategy	"No-operation" strategy that is equivalent to not specifying any strategy: will simply return suggested standard bean naming as-is.
PropertyNamingStrategies.LowerCaseStrategy	Simple strategy where external name simply only uses lower-case characters, and no separators.
PropertyNamingStrategies.LowerDotCaseStrategy	Naming strategy similar to PropertyNamingStrategies.KebabCaseStrategy, but instead of hyphens as separators, uses dots.
PropertyNamingStrategies.NamingBase	Intermediate base class for simple implementations
PropertyNamingStrategies.SnakeCaseStrategy	A PropertyNamingStrategy that translates typical camel case Java property names to lower case JSON element names, separated by underscores.
PropertyNamingStrategies.UpperCamelCaseStrategy	A PropertyNamingStrategy that translates typical camelCase Java property names to PascalCase JSON element names (i.e., with a capital first letter).
PropertyNamingStrategies.UpperSnakeCaseStrategy	A PropertyNamingStrategy that translates an input to the equivalent upper case snake case.
PropertyNamingStrategy	Class that defines how names of JSON properties ("external names") are derived from names of POJO methods and fields ("internal names"), in cases where no explicit annotations exist for naming.
PropertyNamingStrategy.KebabCaseStrategy	Deprecated. Since 2.12 use PropertyNamingStrategies.KebabCaseStrategy instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.LowerCaseStrategy	Deprecated. Since 2.12 use PropertyNamingStrategies.LowerCaseStrategy instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy	Deprecated. In 2.7 use PropertyNamingStrategies.SnakeCaseStrategy instead
PropertyNamingStrategy.LowerDotCaseStrategy	Deprecated. Since 2.12 use PropertyNamingStrategies.LowerDotCaseStrategy instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.PascalCaseStrategy	Deprecated. In 2.7 use PropertyNamingStrategies.UpperCamelCaseStrategy instead
PropertyNamingStrategy.PropertyNamingStrategyBase	Deprecated. Since 2.12 deprecated.
PropertyNamingStrategy.SnakeCaseStrategy	Deprecated. Since 2.12 use PropertyNamingStrategies.SnakeCaseStrategy instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.UpperCamelCaseStrategy	Deprecated. Since 2.12 use PropertyNamingStrategies.UpperCamelCaseStrategy instead (see databind#2715 for reason for deprecation)
PropertySerializerMap	Helper container used for resolving serializers for dynamic (possibly but not necessarily polymorphic) properties: properties whose type is not forced to use dynamic (declared) type and that are not final.
PropertySerializerMap.SerializerAndMapResult	Value class used for returning tuple that has both serializer that was retrieved and new map instance
PropertyValue	Base class for property values that need to be buffered during deserialization.
PropertyValueBuffer	Simple container used for temporarily buffering a set of PropertyValues.
PropertyWriter	Base class for writers used to output property values (name-value pairs) as key/value pairs via streaming API.
RawSerializer<T>	This is a simple dummy serializer that will just output raw values by calling toString() on value to serialize.
RawValue	Helper class used to encapsulate "raw values", pre-encoded textual content that can be output as opaque value with no quoting/escaping, using JsonGenerator.writeRawValue(String).
ReadableObjectId	Simple value container for containing information about single Object Id during deserialization
ReadableObjectId.Referring
ReadOnlyClassToSerializerMap	Optimized lookup table for accessing two types of serializers; typed and non-typed.
ReferenceType	Specialized SimpleType for types that are referential types, that is, values that can be dereferenced to another value (or null), of different type.
ReferenceTypeDeserializer<T>	Base deserializer implementation for properties ReferenceType values.
ReferenceTypeSerializer<T>	Base implementation for values of ReferenceType.
ResolvableDeserializer	Interface used to indicate deserializers that want to do post-processing after construction but before being returned to caller (and possibly cached) and used.
ResolvableSerializer	Interface used to indicate serializers that want to do post-processing after construction and being added to SerializerProvider, but before being used.
ResolvedRecursiveType	Internal placeholder type used for self-references.
RootNameLookup	Helper class for caching resolved root names.
RuntimeJsonMappingException	Wrapper used when interface does not allow throwing a checked JsonMappingException
SchemaAware	Marker interface for schema-aware serializers.
SequenceWriter	Writer class similar to ObjectWriter, except that it can be used for writing sequences of values, not just a single value.
SerializableSerializer	Generic handler for types that implement JsonSerializable.
SerializationConfig	Object that contains baseline configuration for serialization process.
SerializationFeature	Enumeration that defines simple on/off features that affect the way Java objects are serialized.
SerializerCache	Simple cache object that allows for doing 2-level lookups: first level is by "local" read-only lookup Map (used without locking) and second backup level is by a shared modifiable HashMap.
SerializerFactory	Abstract class that defines API used by SerializerProvider to obtain actual JsonSerializer instances from multiple distinct factories.
SerializerFactoryConfig	Configuration settings container class for SerializerFactory implementations.
SerializerProvider	Class that defines API used by ObjectMapper and JsonSerializers to obtain serializers capable of serializing instances of specific types; as well as the default implementation of the functionality.
Serializers	Interface that defines API for simple extensions that can provide additional serializers for various types.
Serializers.Base	Basic Serializers implementation that implements all methods but provides no serializers.
SettableAnyProperty	Class that represents a "wildcard" set method which can be used to generically set values of otherwise unmapped (aka "unknown") properties read from Json content.
SettableBeanProperty	Base class for deserializable properties of a bean: contains both type and name definitions, and reflection-based set functionality.
SettableBeanProperty.Delegating	Helper class that is designed to both make it easier to sub-class delegating subtypes and to reduce likelihood of breakage when new methods are added.
SetterlessProperty	This concrete sub-class implements Collection or Map property that is indirectly by getting the property value and directly modifying it.
ShortNode	Numeric node that contains simple 16-bit integer values.
SimpleAbstractTypeResolver	Simple AbstractTypeResolver implementation, which is based on static mapping from abstract super types into sub types (concrete or abstract), but retaining generic parameterization.
SimpleBeanPropertyDefinition	Simple immutable BeanPropertyDefinition implementation that can be wrapped around a AnnotatedMember that is a simple accessor (getter) or mutator (setter, constructor parameter) (or both, for fields).
SimpleBeanPropertyFilter	Simple PropertyFilter implementation that only uses property name to determine whether to serialize property as is, or to filter it out.
SimpleBeanPropertyFilter.FilterExceptFilter	Filter implementation which defaults to filtering out unknown properties and only serializes ones explicitly listed.
SimpleBeanPropertyFilter.SerializeExceptFilter	Filter implementation which defaults to serializing all properties, except for ones explicitly listed to be filtered out.
SimpleDeserializers	Simple implementation Deserializers which allows registration of deserializers based on raw (type erased class).
SimpleFilterProvider	Simple FilterProvider implementation that just stores direct id-to-filter mapping.
SimpleKeyDeserializers	Simple implementation KeyDeserializers which allows registration of deserializers based on raw (type erased class).
SimpleMixInResolver	Simple implementation of ClassIntrospector.MixInResolver that just uses a Map for containing mapping from target to mix-in classes.
SimpleModule	Vanilla Module implementation that allows registration of serializers and deserializers, bean serializer and deserializer modifiers, registration of subtypes and mix-ins as well as some other commonly needed aspects (addition of custom AbstractTypeResolvers, ValueInstantiators).
SimpleSerializers	Simple implementation Serializers which allows registration of serializers based on raw (type erased class).
SimpleType	Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps).
SimpleValueInstantiators
SqlBlobSerializer	Serializer implementation for Blob to write as binary (for JSON and other formats Base64-encoded String, for binary formats as true binary).
SqlDateSerializer	Compared to regular Date serialization, we do use String representation here.
SqlTimeSerializer
StackTraceElementDeserializer
StaticListSerializerBase<T extends java.util.Collection<?>>	Intermediate base class for Lists, Collections and Arrays that contain static (non-dynamic) value types.
StdArraySerializers	Dummy container class to group standard homogenous array serializer implementations (primitive arrays and String array).
StdArraySerializers.BooleanArraySerializer
StdArraySerializers.CharArraySerializer	Character arrays are different from other integral number arrays in that they are most likely to be textual data, and should be written as Strings, not arrays of entries.
StdArraySerializers.DoubleArraySerializer
StdArraySerializers.FloatArraySerializer
StdArraySerializers.IntArraySerializer
StdArraySerializers.LongArraySerializer
StdArraySerializers.ShortArraySerializer
StdArraySerializers.TypedPrimitiveArraySerializer<T>	Intermediate base class used for cases where we may add type information (excludes boolean/int/double arrays).
StdConverter<IN,OUT>	Standard implementation of Converter that supports explicit type access, instead of relying type detection of generic type parameters.
StdDateFormat	Jackson's internal DateFormat implementation used by standard Date serializers and deserializers to implement default behavior: does NOT fully implement all aspects expected by DateFormat and as a consequence SHOULD NOT to be used by code outside core Jackson databind functionality.
StdDelegatingDeserializer<T>	Deserializer implementation where given Java type is first deserialized by a standard Jackson deserializer into a delegate type; and then this delegate type is converted using a configured Converter into desired target type.
StdDelegatingSerializer	Serializer implementation where given Java type is first converted to an intermediate "delegate type" (using a configured Converter, and then this delegate value is serialized by Jackson.
StdDeserializer<T>	Base class for common deserializers.
StdJdkSerializers	Class that providers access to serializers user for non-structured JDK types that are serializer as scalars; some using basic ToStringSerializer, others explicit serializers.
StdJdkSerializers.AtomicBooleanSerializer
StdJdkSerializers.AtomicIntegerSerializer
StdJdkSerializers.AtomicLongSerializer
StdKeyDeserializer	Default KeyDeserializer implementation used for most Map types Jackson supports.
StdKeyDeserializers	Helper class used to contain simple/well-known key deserializers.
StdKeySerializer	Deprecated. Since 2.8, use StdKeySerializers.Default instead.
StdKeySerializers
StdKeySerializers.Default	This is a "chameleon" style multi-type key serializer for simple standard JDK types.
StdKeySerializers.Dynamic	Key serializer used when key type is not known statically, and actual key serializer needs to be dynamically located.
StdKeySerializers.EnumKeySerializer	Specialized instance to use for Enum keys, as per [databind#1322]
StdKeySerializers.StringKeySerializer	Simple and fast key serializer when keys are Strings.
StdNodeBasedDeserializer<T>	Convenience deserializer that may be used to deserialize values given an intermediate tree representation (JsonNode).
StdScalarDeserializer<T>	Base class for deserializers that handle types that are serialized as JSON scalars (non-structured, i.e.
StdScalarSerializer<T>
StdSerializer<T>	Base class used by all standard serializers, and can also be used for custom serializers (in fact, this is the recommended base class to use).
StdSubtypeResolver	Standard SubtypeResolver implementation.
StdTypeResolverBuilder	Default TypeResolverBuilder implementation.
StdValueInstantiator	Default ValueInstantiator implementation, which supports Creator methods that can be indicated by standard Jackson annotations.
StringArrayDeserializer	Separate implementation for serializing String arrays (instead of using ObjectArrayDeserializer.
StringArraySerializer	Standard serializer used for String[] values.
StringCollectionDeserializer	Specifically optimized version for Collections that contain String values; reason is that this is a very common type and we can make use of the fact that Strings are final.
StringCollectionSerializer	Efficient implement for serializing Collections that contain Strings.
StringDeserializer
StringSerializer	This is the special serializer for regular Strings.
SubtypeResolver	Helper object used for handling registration on resolving of super-types to sub-types.
SubTypeValidator	Helper class used to encapsulate rules that determine subtypes that are invalid to use, even with default typing, mostly due to security concerns.
TextNode	Value node that contains a text value.
ThrowableDeserializer	Deserializer that builds on basic BeanDeserializer but override some aspects like instance construction.
TimeZoneSerializer
ToEmptyObjectSerializer	Simple "bogus" serializer that will just serialize an empty Object for any given value.
TokenBuffer	Utility class used for efficient storage of JsonToken sequences, needed for temporary buffering.
TokenBuffer.Parser
TokenBuffer.Segment	Individual segment of TokenBuffer that can store up to 16 tokens (limited by 4 bits per token type marker requirement).
TokenBufferDeserializer	We also want to directly support deserialization of TokenBuffer.
TokenBufferReadContext	Implementation of JsonStreamContext used by TokenBuffer to link back to the original context to try to keep location information consistent between source location and buffered content when it's re-read from the buffer.
TokenBufferSerializer	We also want to directly support serialization of TokenBuffer; and since it is part of core package, it cannot implement JsonSerializable (which is only included in the mapper package)
ToStringSerializer	Simple general purpose serializer, useful for any type for which Object.toString() returns the desired JSON value.
ToStringSerializerBase	Intermediate base class that serves as base for standard ToStringSerializer as well as for custom subtypes that want to add processing for converting from value to output into its String representation (whereas standard version simply calls value object's toString() method).
TreeTraversingParser	Facade over JsonNode that implements JsonParser to allow accessing contents of JSON tree in alternate form (stream of tokens).
TypeBase
TypeBindings	Helper class used for resolving type parameters for given class
TypeDeserializer	Interface for deserializing type information from JSON content, to type-safely deserialize data into correct polymorphic instance (when type inclusion has been enabled for type handled).
TypeDeserializerBase	Base class for all standard Jackson TypeDeserializers.
TypeFactory	Class used for creating concrete JavaType instances, given various inputs.
TypeIdResolver	Interface that defines standard API for converting types to type identifiers and vice versa.
TypeIdResolverBase	Partial base implementation of TypeIdResolver: all custom implementations are strongly recommended to extend this class, instead of directly implementing TypeIdResolver.
TypeKey	Key that offers two "modes"; one with raw class, as used for cases were raw class type is available (for example, when using runtime type); and one with full generics-including.
TypeModifier	Class that defines API that can be used to modify details of JavaType instances constructed using TypeFactory.
TypeNameIdResolver
TypeParser	Simple recursive-descent parser for parsing canonical JavaType representations and constructing type instances.
TypeResolutionContext	Interface that defines API used by members (like AnnotatedMethod) to dynamically resolve types they have.
TypeResolutionContext.Basic
TypeResolutionContext.Empty	Dummy implementation for case where there are no bindings available (for example, for static methods and fields)
TypeResolverBuilder<T extends TypeResolverBuilder<T>>	Interface that defines builders that are configured based on annotations (like JsonTypeInfo or JAXB annotations), and produce type serializers and deserializers used for handling type information embedded in JSON to allow for safe polymorphic type handling.
TypeSerializer	Interface for serializing type information regarding instances of specified base type (super class), so that exact subtype can be properly deserialized later on.
TypeSerializerBase
TypeWrappedDeserializer	Simple deserializer that will call configured type deserializer, passing in configured data deserializer, and exposing it all as a simple deserializer.
TypeWrappedSerializer	Simple serializer that will call configured type serializer, passing in configured data serializer, and exposing it all as a simple serializer.
UnknownSerializer
UnrecognizedPropertyException	Specialized JsonMappingException sub-class specifically used to indicate problems due to encountering a JSON property that could not be mapped to an Object property (via getter, constructor argument or field).
UnresolvedForwardReference	Exception thrown during deserialization when there are object id that can't be resolved.
UnresolvedId	Helper class for UnresolvedForwardReference, to contain information about unresolved ids.
UnsupportedTypeDeserializer	Special bogus "serializer" that will throw MismatchedInputException if an attempt is made to deserialize a value.
UnsupportedTypeSerializer	Special bogus "serializer" that will throw InvalidDefinitionException if its UnsupportedTypeSerializer.serialize(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) gets invoked.
UntypedObjectDeserializer	Deserializer implementation that is used if it is necessary to bind content of "unknown" type; something declared as basic Object (either explicitly, or due to type erasure).
UntypedObjectDeserializer.Vanilla	Streamlined version of UntypedObjectDeserializer that has fewer checks and is only used when no custom deserializer overrides are applied.
UnwrappedPropertyHandler	Object that is responsible for handling acrobatics related to deserializing "unwrapped" values; sets of properties that are embedded (inlined) as properties of parent JSON object.
UnwrappingBeanPropertyWriter	Variant of BeanPropertyWriter which will handle unwrapping of JSON Object (including of properties of Object within surrounding JSON object, and not as sub-object).
UnwrappingBeanSerializer
UUIDDeserializer
UUIDSerializer	Specialized JsonSerializer to output UUIDs.
ValueInjector	Class that encapsulates details of value injection that occurs before deserialization of a POJO.
ValueInstantiationException	Exception type used for generic failures during processing by ValueInstantiator: commonly used to wrap exceptions thrown by constructor or factory method.
ValueInstantiator	Class that defines simple API implemented by objects that create value instances.
ValueInstantiator.Base	Partial ValueInstantiator implementation that is strongly recommended to be used instead of directly extending ValueInstantiator itself.
ValueInstantiator.Delegating	Delegating ValueInstantiator implementation meant as a base type that by default delegates methods to specified fallback instantiator.
ValueInstantiator.Gettable
ValueInstantiators	Interface for providers of ValueInstantiator instances.
ValueInstantiators.Base	Basic "NOP" implementation that can be used as the base class for custom implementations.
ValueNode	This intermediate base class is used for all leaf nodes, that is, all non-container (array or object) nodes, except for the "missing node".
ViewMatcher	Helper class used for checking whether a property is visible in the active view
VirtualAnnotatedMember	Placeholder used by virtual properties as placeholder for underlying AnnotatedMember.
VirtualBeanPropertyWriter	BeanPropertyWriter implementation used with JsonAppend to add "virtual" properties in addition to regular ones.
VisibilityChecker<T extends VisibilityChecker<T>>	Interface for object used for determine which property elements (methods, fields, constructors) can be auto-detected, with respect to their visibility modifiers.
VisibilityChecker.Std	Default standard implementation is purely based on visibility modifier of given class members, and its configured minimum levels.
WithMember<T>
WritableObjectId	Simple value container used to keep track of Object Ids during serialization.