All Classes

Class	Description
AbstractDeserializer	Deserializer only used as placeholder for abstract types during polymorphic type handling deserialization.
AbstractTypeMaterializer	Nifty class for pulling implementations of classes out of thin air.
AbstractTypeMaterializer.Feature	Enumeration that defines togglable features that guide the serialization feature.
AbstractTypeResolver	Defines interface for resolvers that can resolve abstract types into concrete ones; either by using static mappings, or possibly by materializing implementations dynamically.
Annotated	Shared base class used for anything on which annotations (included within a AnnotationMap).
AnnotatedClass
AnnotatedConstructor
AnnotatedField	Object that represents non-static (and usually non-transient/volatile) fields of a class.
AnnotatedMember	Intermediate base class for annotated entities that are members of a class; fields, methods and constructors.
AnnotatedMethod
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.
AnnotationIntrospector	Abstract class that defines API used for introspecting annotation-based configuration for serialization and deserialization.
AnnotationIntrospector.Pair	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.
AnnotationIntrospector.ReferenceProperty	Value type used with managed and back references; contains type and logic name, used to link related references
AnnotationIntrospector.ReferenceProperty.Type
AnnotationMap	Simple helper class used to keep track of collection of Jackson Annotations associated with annotatable things (methods, constructors, classes).
Annotations	Enumeration that defines standard annotation sets available for configuring data binding aspects.
Annotations	Interface that defines interface for collection of annotations.
AnyGetterWriter	Class similar to BeanPropertyWriter, but that will be used for serializing JsonAnyGetter annotated (Map) properties
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
ArrayDeserializer	Deprecated. Since 1.9, use ObjectArrayDeserializer instead.
ArrayDeserializers	Deprecated. Since 1.9, use PrimitiveArrayDeserializers instead.
ArrayNode	Node class that represents Arrays mapped from Json content.
ArraySerializers	Deprecated. Since 1.9 use StdArraySerializers
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.
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
AtomicReferenceDeserializer
Base64Variant	Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used.
Base64Variants	Container for commonly used Base64 variants.
BaseJsonNode	Abstract base class common to all standard JsonNode implementations.
BasicBeanDescription	Default BeanDescription implementation.
BasicClassIntrospector
BasicClassIntrospector.GetterMethodFilter	Deprecated. Since 1.9 just don't use
BasicClassIntrospector.SetterAndGetterMethodFilter	Deprecated. Since 1.9 just don't use
BasicClassIntrospector.SetterMethodFilter	Deprecated. Since 1.9 just don't use
BasicDeserializerFactory	Abstract factory base class that can provide deserializers for standard JDK classes, including collection classes and simple heuristics for "upcasting" commmon collection interface types (such as Collection).
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).
BeanBuilder	Heavy lifter of mr Bean package: class that keeps track of logical POJO properties, and figures out how to create an implementation class.
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, but possibly also from simple types like String values.
BeanDeserializerBuilder	Builder class used for aggregating deserialization information about a POJO, in order to build a JsonDeserializer for deserializing intances.
BeanDeserializerFactory	Concrete deserializer factory class that adds full Bean deserializer construction logic using class introspection.
BeanDeserializerFactory.ConfigImpl	Standard configuration settings container class implementation.
BeanDeserializerModifier	Abstract class that defines API for objects that can be registered (for BeanDeserializerFactory to participate in constructing BeanDeserializer instances.
BeanProperty	Bean properties are logical entities that represent data Java objects ("beans", although more accurately POJOs) contain; and that are accessed using some combination of methods (getter, setter), field and constructor parameter.
BeanProperty.Std
BeanPropertyDefinition	Simple value classes that contain definitions of properties, used during introspection of properties to use for serialization and deserialization purposes.
BeanPropertyFilter	Interface that defines API for filter objects use (as configured using JsonFilter) for filtering bean properties to serialize.
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 arbitrary bean objects
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.
BeanSerializerFactory.ConfigImpl	Configuration settings container class for bean serializer factory
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.
BeanUtil
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.
BufferRecycler	This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
BufferRecycler.ByteBufferType
BufferRecycler.CharBufferType
ByteArrayBuilder	Helper class that is similar to ByteArrayOutputStream in usage, but more geared to Jackson use cases internally.
ByteSourceBootstrapper	This class is used to determine the encoding of byte stream that is to contain JSON content.
BytesToNameCanonicalizer	A caching symbol table implementation used for canonicalizing JSON field names (as Names which are constructed directly from a byte-based input source).
CalendarDeserializer
CalendarSerializer	Standard serializer for Calendar.
CharacterEscapes	Abstract base class that defines interface for customizing character escaping aspects for String values, for formats that use escaping.
CharsToNameCanonicalizer	This class is a kind of specialized type-safe Map, from char array to String value.
CharTypes
ClassDeserializer
ClassIntrospector<T extends BeanDescription>	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.
ClassUtil
CollectionDeserializer	Deprecated. Since 1.9, use ContainerDeserializerBase instead.
CollectionDeserializer	Basic serializer that can take JSON "Array" structure and construct a Collection instance, with typed contents.
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).
Comparators	Helper class for constructing objects for comparing content values
ContainerDeserializer<T>	Deprecated. Since 1.9, use ContainerDeserializerBase instead.
ContainerDeserializerBase<T>	Intermediate base deserializer class that adds more shared accessor so that other classes can access information about contained (value) types
ContainerNode	This intermediate base class is used for all container nodes, specifically, array and object nodes.
ContainerNode.NoNodesIterator
ContainerNode.NoStringsIterator
ContainerSerializerBase<T>	Intermediate base class for types that contain element(s) of other types.
ContainerSerializers	Deprecated. Since 1.9 use StdContainerSerializers instead
ContextualDeserializer<T>	Add-on interface that JsonDeserializers can implement to get a callback that can be used to create contextual 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<T>	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.
CoreXMLDeserializers	Container deserializers that handle "core" XML types: ones included in standard JDK 1.5.
CoreXMLDeserializers.DurationDeserializer
CoreXMLDeserializers.GregorianCalendarDeserializer
CoreXMLDeserializers.QNameDeserializer
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
CreatorCollector	Container class for storing information on creators (based on annotations, visibility), to be able to build actual instantiator later on.
CreatorProperty	This concrete sub-class implements property that is passed via Creator (constructor or static factory method).
CustomDeserializerFactory	Deprecated. Starting with 1.7, functionality of this class has been implemented both in base SerializerFactory (see methods like SerializerFactory.withAdditionalSerializers(Serializers)) and through new Module API.
CustomSerializerFactory	Serializer factory implementation that allows for configuring mapping between types (classes) and serializers to use, by using multiple types of overrides.
DataFormatDetector	Simple helper class that allows data format (content type) auto-detection, given an ordered set of JsonFactory instances to use for actual low-level detection.
DataFormatMatcher	Result object constructed by DataFormatDetector when requested to detect format of given input data.
DataHandlerJsonDeserializer
DataHandlerJsonSerializer
DateDeserializer	Deprecated. Since 1.9, use JsonNodeDeserializer instead.
DateDeserializer	Simple deserializer for handling Date values.
DateSerializer	For efficiency, we will serialize Dates as longs, instead of potentially more readable Strings.
DecimalNode	Numeric node that contains values that do not fit in simple integer (int, long) or floating point (double) values.
DefaultPrettyPrinter	Deprecated. Moved to DefaultPrettyPrinter; will be removed in Jackson 2.0
DefaultPrettyPrinter	Default PrettyPrinter implementation that uses 2-space indentation with platform-default linefeeds.
DefaultPrettyPrinter.FixedSpaceIndenter	This is a very simple indenter that only every adds a single space for indentation.
DefaultPrettyPrinter.Lf2SpacesIndenter	Default linefeed-based indenter uses system-specific linefeeds and 2 spaces for indentation per level.
DefaultPrettyPrinter.NopIndenter	Dummy implementation that adds no indentation whatsoever
DeserializationConfig	Object that contains baseline configuration for deserialization process.
DeserializationConfig.Feature	Enumeration that defines togglable features that guide the serialization feature.
DeserializationContext	Context for deserialization process.
DeserializationProblemHandler	This is the class that can be registered (via DeserializationConfig object owner by ObjectMapper) to get calledn when a potentially recoverable problem is encountered during deserialization process.
DeserializerFactory	Abstract class that defines API used by DeserializerProvider to obtain actual JsonDeserializer instances from multiple distinct factories.
DeserializerFactory.Config	Configuration settings container class for bean deserializer factory
DeserializerProvider	Abstract class that defines API used by ObjectMapper and JsonDeserializers to obtain deserializers capable of re-constructing instances of handled type from JSON content.
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.
Deserializers.None	Deprecated. As of 1.9, use Deserializers.Base instead
DOMDeserializer<T>	Base for serializers that allows parsing DOM Documents from JSON Strings.
DOMDeserializer.DocumentDeserializer
DOMDeserializer.NodeDeserializer
DomElementJsonDeserializer
DomElementJsonSerializer
DOMSerializer
DoubleNode	Numeric node that contains 64-bit ("double precision") floating point values simple 32-bit integer values.
EnumDeserializer	Deprecated. Since 1.9, use EnumDeserializer instead.
EnumDeserializer	Deserializer class that can deserialize instances of specified Enum class from Strings and Integers.
EnumDeserializer.FactoryBasedDeserializer	Deserializer that uses a single-String static factory method for locating Enum values by String id.
EnumMapDeserializer	Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumMap, V>
EnumMapSerializer	Specialized serializer for EnumMaps.
EnumResolver<T extends java.lang.Enum<T>>	Deprecated. Since 1.9, use EnumResolver instead.
EnumResolver<T extends java.lang.Enum<T>>	Helper class used to resolve String values (either JSON Object field names or regular String values) into Java Enum instances.
EnumSerializer	Deprecated. Since 1.9 use EnumSerializer
EnumSerializer	Standard serializer used for Enum types.
EnumSetDeserializer	Note: casting within this class is all messed up -- just could not figure out a way to properly deal with recursive definition of "EnumSet, V>
EnumSetSerializer
EnumValues	Helper class used for storing String serializations of enumerations.
ExternalTypeHandler	Helper class that is used to flatten JSON structure when using "external type id" (see JsonTypeInfo.As.EXTERNAL_PROPERTY).
ExternalTypeHandler.Builder
FailingSerializer	Special bogus "serializer" that will throw JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider) gets invoked.
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 BeanPropertyFilter that match given ids.
FormatSchema	Simple tag interface used to mark schema objects that are used by some JsonParser and JsonGenerator implementations to further specify structure of expected format.
FromStringDeserializer<T>	Deprecated. Since 1.9, use FromStringDeserializer instead.
FromStringDeserializer<T>	Base class for simple deserializer which only accept JSON String values as the source.
FromStringDeserializer.CharsetDeserializer
FromStringDeserializer.CurrencyDeserializer
FromStringDeserializer.InetAddressDeserializer	As per [JACKSON-484], also need special handling for InetAddress...
FromStringDeserializer.LocaleDeserializer	Kept protected as it's not meant to be extensible at this point
FromStringDeserializer.PatternDeserializer
FromStringDeserializer.TimeZoneDeserializer	As per [JACKSON-522], also need special handling for InetAddress...
FromStringDeserializer.URIDeserializer
FromStringDeserializer.URLDeserializer
FromStringDeserializer.UUIDDeserializer
HandlerInstantiator	Helper class used for handling details of creating handler instances (things like JsonSerializers, JsonDeserializers, various type handlers) of specific types.
HierarchicType	Simple replacement for Class (and/or various Type subtypes) that is used as part of single-path extends/implements chain to express specific relationship between one subtype and one supertype.
Indenter	Interface that defines objects that can produce indentation used to separate object entries and array values.
IndexedStringListSerializer	Efficient implementation for serializing Lists that contains Strings and are random-accessible.
InetAddressSerializer	Simple serializer for InetAddress.
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.
InputAccessor	Interface used to expose beginning of a data file to data format detection code.
InputAccessor.Std	Basic implementation that reads data from given InputStream and buffers it as necessary.
InputDecorator	Handler class that can be used to decorate input sources.
InternCache	Singleton class that adds a simple first-level cache in front of regular String.intern() functionality.
IntNode	Numeric node that contains simple 32-bit integer values.
IOContext	To limit number of configuration and state objects to pass, all contextual objects that need to be passed by the factory to readers and writers are combined under this object.
ISO8601DateFormat	Provide a fast thread-safe formatter/parser DateFormat for ISO8601 dates ONLY.
ISO8601Utils	Utilities methods for manipulating dates in iso8601 format.
IterableSerializer
JacksonAnnotation	Meta-annotation (annotations used on other annotations) used for marking all annotations that are part of Jackson package.
JacksonAnnotationIntrospector	AnnotationIntrospector implementation that handles standard Jackson annotations.
JacksonInject	Jackson-specific annotation used for indicating that value of annotated property will be "injected", i.e.
JacksonJaxbJsonProvider	JSON content type provider automatically configured to use both Jackson and JAXB annotations (in that order of priority).
JacksonJsonProvider	Basic implementation of JAX-RS abstractions (MessageBodyReader, MessageBodyWriter) needed for binding JSON ("application/json") content to and from Java Objects ("POJO"s).
JacksonStdImpl	Marker interface used to indicate implementation classes (serializers, deserializers etc) that are standard ones Jackson uses; not custom ones that application has added.
JavaType	Base class for type token classes used both to contain information and as keys for deserializers.
JavaTypeDeserializer
JaxbAnnotationIntrospector	Annotation introspector that leverages JAXB annotations where applicable to JSON mapping.
JdkSerializers	Deprecated. Since 1.9 use StdJdkSerializers
JodaDeserializers	Provider for deserializers that handle some basic data types for Joda date/time library.
JodaDeserializers.DateMidnightDeserializer
JodaDeserializers.DateTimeDeserializer<T extends org.joda.time.ReadableInstant>	Basic deserializer for DateTime.
JodaDeserializers.LocalDateDeserializer
JodaDeserializers.LocalDateTimeDeserializer
JodaDeserializers.PeriodDeserializer
JodaSerializers	Provider for serializers that handle some basic data types for Joda date/time library.
JodaSerializers.DateMidnightSerializer
JodaSerializers.DateTimeSerializer
JodaSerializers.JodaSerializer<T>
JodaSerializers.LocalDateSerializer
JodaSerializers.LocalDateTimeSerializer
JsonAnyGetter	Marker annotation that can be used to define a non-static, no-argument method or member field as something of a reverse of JsonAnySetter method; basically being used like a getter but such that contents of the returned Map (type must be Map) are serialized as if they were actual properties of the bean that contains method/field with this annotations.
JsonAnySetter	Marker annotation that can be used to define a non-static, single-argument method, to be used as a "fallback" handler for all otherwise unrecognized properties found from Json content.
JsonAutoDetect	Class annotation that can be used to define which kinds of Methods are to be detected by auto-detection.
JsonAutoDetect.Visibility	Enumeration for possible visibility thresholds (minimum visibility) that can be used to limit which methods (and fields) are auto-detected.
JsonBackReference	Annotation used to indicate that associated property is part of two-way linkage between fields; and that its role is "child" (or "back") link.
JsonCachable	Marker annotation used to denote whether given instance (currently only used with JsonDeserializer) can be cached.
JsonCreator	Marker annotation that can be used to define constructors and factory methods as one to use for instantiating new instances of the associated class.
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.
JsonEncoding	Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification.
JsonFactory	The main factory class of Jackson package, used to configure and construct reader (aka parser, JsonParser) and writer (aka generator, JsonGenerator) instances.
JsonFilter	Annotation used to indicate which logical filter is to be used for filtering out properties of type (class) annotated; association made by this annotation declaring ids of filters, and ObjectMapper (or objects it delegates to) providing matching filters by id.
JsonGenerationException	Exception type for exceptions during JSON writing, such as trying to output content in wrong context (non-matching end-array or end-object, for example).
JsonGenerator	Base class that defines public API for writing JSON content.
JsonGenerator.Feature	Enumeration that defines all togglable features for generators.
JsonGeneratorBase	This base class implements part of API that a JSON generator exposes to applications, adds shared internal methods that sub-classes can use and adds some abstract methods sub-classes must implement.
JsonGeneratorDelegate
JsonGetter	Deprecated. Use JsonProperty instead (deprecated since version 1.5)
JsonIgnore	Marker annotation that indicates that the annotated method or field is to be ignored by introspection-based serialization and deserialization functionality.
JsonIgnoreProperties	Annotation that can be used to either suppress serialization of properties (during serialization), or ignore processing of JSON properties read (during deserialization).
JsonIgnoreType	Marker annotation that indicates that all properties of annotated type are to be ignored during serialization and deserialization.
JsonLocation	Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams.
JsonManagedReference	Annotation used to indicate that annotated property is part of two-way linkage between fields; and that its role is "parent" (or "forward") link.
JsonMappingException	Checked exception used to signal fatal problems with mapping of content.
JsonMappingException.Reference	Simple bean class used to contain references.
JsonMappingExceptionMapper	Implementation if ExceptionMapper to send down a "400 Bad Request" response in the event that unmappable JSON is received.
JsonMethod	Enumeration used to define kinds of methods that annotations like JsonAutoDetect apply to.
JsonNode	Base class for all JSON nodes, which form the basis of JSON Tree Model that Jackson implements.
JsonNodeDeserializer	Deprecated. Since 1.9, use JsonNodeDeserializer instead.
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.
JsonNumericParserBase	Deprecated. Since 1.9.0: functionality demoted down to JsonParserBase
JsonParseException	Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered.
JsonParseExceptionMapper	Implementation of ExceptionMapper to send down a "400 Bad Request" in the event unparsable JSON is received.
JsonParser	Base class that defines public API for reading JSON content.
JsonParser.Feature	Enumeration that defines all togglable features for parsers.
JsonParser.NumberType	Enumeration of possible "native" (optimal) types that can be used for numbers.
JsonParserBase	Intermediate base class used by all Jackson JsonParser implementations.
JsonParserDelegate	Helper class that implements delegation pattern for JsonParser, to allow for simple overridability of basic parsing functionality.
JsonParserMinimalBase	Intermediate base class used by all Jackson JsonParser implementations, but does not add any additional fields that depend on particular method of obtaining input.
JsonParserSequence	Helper class that can be used to sequence multiple physical JsonParsers to create a single logical sequence of tokens, as a single JsonParser.
JSONPObject	Container class that can be used to wrap any Object instances (including nulls), and will serialize embedded in JSONP wrapping.
JsonProcessingException	Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems.
JsonProperty	Marker annotation that can be used to define a non-static method as a "setter" or "getter" for a logical property (depending on its signature), or non-static object field to be used (serialized, deserialized) as a logical property.
JsonPropertyOrder	Annotation that can be used to define ordering (possibly partial) to use when serializing object properties.
JsonRawValue	Marker annotation that indicates that the annotated method or field should be serialized by including literal String value of the property as is, without quoting of characters.
JsonReadContext	Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to parser implementation classes.
JsonRootName	Annotation similar to XmlRootElement, used to indicate name to use for root-level wrapping, if wrapping is enabled.
JsonSchema	A JsonNode that represents a JSON-Schema instance.
JsonSerializable	Deprecated.
JsonSerializableSchema	Annotation that can be used to define JSON Schema definition for the annotated class.
JsonSerializableWithType	Interface that is to replace JsonSerializable to allow for dynamic type information embedding.
JsonSerialize	Annotation used for configuring serialization aspects, by attaching to "getter" methods or fields, or to value classes.
JsonSerialize.Inclusion	Enumeration used with JsonSerialize.include() property to define which properties of Java Beans are to be included in serialization
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.
JsonSerializerMap	Specialized read-only map used for storing and accessing serializers by type.
JsonSetter	Marker annotation that can be used to define a non-static, single-argument method to be used as a "setter" for a logical property as an alternative to recommended JsonProperty annotation (which was introduced in version 1.1).
JsonStreamContext	Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API.
JsonStringEncoder	Helper class used for efficient encoding of JSON String values (including JSON field names) into Strings or UTF-8 byte arrays.
JsonSubTypes	Annotation used with JsonTypeInfo to indicate sub types of serializable polymorphic types, and to associate logical names used within JSON content (which is more portable than using physical Java class names).
JsonSubTypes.Type	Definition of a subtype, along with optional name.
JsonToken	Enumeration for basic token types used for returning results of parsing JSON content.
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.
JsonTypeInfo	Annotation used for configuring details of if and how type information is used with JSON serialization and deserialization, to preserve information about actual class of Object instances.
JsonTypeInfo.As	Definition of standard type inclusion mechanisms for type metadata.
JsonTypeInfo.Id	Definition of different type identifiers that can be included in JSON during serialization, and used for deserialization.
JsonTypeInfo.None	This marker class that is only to be used with defaultImpl annotation property, to indicate that there is no default implementation specified.
JsonTypeName	Annotation used for binding logical name that the annotated class has.
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)
JsonUnwrapped	Annotation used to indicate that a property should be serialized "unwrapped"; that is, if it would be serialized as JSON Object, its properties are instead included as properties of its containing Object.
JsonValue	Marker annotation similar to XmlValue that indicates that results of the annotated "getter" method (which means signature must be that of getters; non-void return type, no args) is to be used as the single value to serialize for the instance.
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.
JsonView	Annotation used for indicating view(s) that the property that is defined by method or field annotated is part of.
JSONWrappedObject	General-purpose wrapper class that can be used to decorate serialized value with arbitrary literal prefix and suffix.
JsonWriteContext	Extension of JsonStreamContext, which implements core methods needed, and also exposes more complete API to generator implementation classes.
JsonWriteNullProperties	Deprecated. (since 1.6) Currently recommended annotation to use is JsonSerialize.include() (with values ALWAYS or NON_NULL)
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.
LinkedNode<T>	Node of a forward-only linked list.
LongNode	Numeric node that contains simple 64-bit integer values.
LRUMap<K,V>	Helper for simple bounded LRU maps used for reusing lookup values.
MapDeserializer	Deprecated. Since 1.9, use MapDeserializer instead.
MapDeserializer	Basic serializer that can take Json "Object" structure and construct a Map instance, with typed contents.
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.
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.
MapperConfig.Base	Immutable container class used to store simple configuration settings.
MapperConfig.ConfigFeature	Interface that actual Feature enumerations used by MapperConfig implementations must implement.
MapperConfigurator	Helper class used to encapsulate details of configuring an ObjectMapper instance to be used for data binding, as well as accessing it.
MappingIterator<T>	Iterator exposed by ObjectMapper when binding sequence of objects.
MappingJsonFactory	Sub-class of JsonFactory that will create a proper ObjectCodec to allow seamless conversions between Json content and Java objects (POJOs).
MapSerializer	Deprecated. Since 1.9 use MapSerializer
MapSerializer	Standard serializer implementation for serializing {link java.util.Map} types.
MapType	Type that represents "true" Java Map types.
MatchStrength	Enumeration used to indicate strength of match between data format and piece of data (typically beginning of a data file).
MemberKey	Helper class needed to be able to efficiently access class member functions (Methods and Constructors) in Maps.
MergedStream	Simple InputStream implementation that is used to "unwind" some data previously read from an input stream; so that as long as some of that data remains, it's returned; but as long as it's read, we'll just use data from the underlying original stream.
MethodFilter	Simple interface that defines API used to filter out irrelevant methods
MinimalClassNameIdResolver
MinimalPrettyPrinter	PrettyPrinter implementation that adds no indentation, just implements everything necessary for value output to work as expected, and provide simpler extension points to allow for creating simple custom implementations that add specific decoration or overrides.
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.
MrBeanModule
Name	Base class for tokenized names (key strings in objects) that have been tokenized from byte-based input sources (like InputStream.
Name1	Specialized implementation of PName: can be used for short Strings that consists of at most 4 bytes.
Name2	Specialized implementation of PName: can be used for short Strings that consists of 5 to 8 bytes.
Name3	Specialized implementation of PName: can be used for short Strings that consists of 9 to 12 bytes.
Named	Simple tag interface mostly to allow sorting by name
NamedType	Simple container class for types with optional logical name, used as external identifier
NameN	Generic implementation of PName used for "long" names, where long means that its byte (UTF-8) representation is 13 bytes or more.
NoClass	Marker class used with annotations to indicate "no class".
NonTypedScalarSerializerBase<T>	Intermediate base class for limited number of scalar types that should never include type information.
NopAnnotationIntrospector	Dummy, "no-operation" implementation of AnnotationIntrospector.
NullNode	This singleton value class is used to contain explicit JSON null value.
NullSerializer	This is a simple dummy serializer that will just output literal JSON null value whenever serialization is requested.
NumberInput
NumberOutput
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).
ObjectCodec	Abstract class that defines the interface that JsonParser and JsonGenerator use to serialize and deserialize regular Java objects (POJOs aka Beans).
ObjectMapper	This mapper (or, data binder, or codec) provides functionality for converting between Java objects (instances of JDK provided core classes, beans), and matching JSON constructs.
ObjectMapper.DefaultTypeResolverBuilder	Customized TypeResolverBuilder that provides type resolver builders used with so-called "default typing" (see ObjectMapper.enableDefaultTyping() for details).
ObjectMapper.DefaultTyping	Enumeration used with ObjectMapper.enableDefaultTyping() to specify what kind of types (classes) default typing should be used for.
ObjectNode	Node that maps to JSON Object structures in JSON content.
ObjectNode.NoFieldsIterator	For efficiency, let's share the "no fields" iterator...
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.
OptionalHandlerFactory	Helper class used for isolating details of handling optional+external types (Joda datetime, javax.xml classes) from standard factories that offer them.
OutputDecorator	Handler class that can be used to decorate output destinations.
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.
PrettyPrinter	Interface for objects that implement pretty printer functionality, such as indentation.
PrimitiveArrayBuilder<T>	Base class for specialized primitive array builders.
PrimitiveArrayDeserializers	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.
PropertyBuilder	Helper class for BeanSerializerFactory that is used to construct BeanPropertyWriter instances.
PropertyBuilder.EmptyArrayChecker	Helper object used to check if given array object is null or empty
PropertyBuilder.EmptyCollectionChecker	Helper object used to check if given Collection object is null or empty
PropertyBuilder.EmptyMapChecker	Helper object used to check if given Map object is null or empty
PropertyBuilder.EmptyStringChecker	Helper object used to check if given String object is null or empty
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 they are not auto-detected and no explicit annotations exist for naming.
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy	A PropertyNamingStrategy that translates typical camel case Java property names to lower case JSON element names, separated by underscores.
PropertyNamingStrategy.PropertyNamingStrategyBase
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.
Provider<T>	Simple helper class used for decoupling instantiation of optionally loaded handlers, like deserializers and deserializers for libraries that are only present on some platforms.
RawSerializer<T>	This is a simple dummy serializer that will just output raw values by calling toString() on value to serialize.
ReaderBasedParser	This is a concrete implementation of JsonParser, which is based on a Reader to handle low-level character conversion tasks.
ReaderBasedParserBase	Deprecated. Since 1.9 sub-classes should just include code from here as is.
ReadOnlyClassToSerializerMap	Optimized lookup table for accessing two types of serializers; typed and non-typed.
ResolvableDeserializer	Interface used to indicate deserializers that want to do post-processing after construction and being added to DeserializerProvider, but before being used.
ResolvableSerializer	Interface used to indicate serializers that want to do post-processing after construction and being added to SerializerProvider, but before being used.
RootNameLookup	Helper class for caching resolved root names.
RuntimeJsonMappingException	Wrapper used when interface does not allow throwing a checked JsonMappingException
ScalarSerializerBase<T>	Deprecated. Since 1.9 use SerializerBase instead.
ScalarSerializerBase<T>
SchemaAware	Marker interface for schema-aware serializers.
SegmentedStringWriter	Efficient alternative to StringWriter, based on using segmented internal buffer.
SerializableSerializer	Generic handler for types that implement JsonSerializable.
SerializableString	Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations.
SerializableWithTypeSerializer	Generic handler for types that implement JsonSerializableWithType.
SerializationConfig	Object that contains baseline configuration for serialization process.
SerializationConfig.Feature	Enumeration that defines togglable features that guide the serialization feature.
SerializedString	String token that can lazily serialize String contained and then reuse that serialization later on.
SerializerBase<T>	Deprecated. Since 1.9 use SerializerBase
SerializerBase<T>	Base class used by all standard serializers.
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.
SerializerCache.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.
SerializerFactory	Abstract class that defines API used by SerializerProvider to obtain actual JsonSerializer instances from multiple distinct factories.
SerializerFactory.Config	Configuration settings container class for bean serializer factory.
SerializerProvider	Abstract class that defines API used by ObjectMapper and JsonSerializers to obtain serializers capable of serializing instances of specific types.
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.
Serializers.None	Deprecated. As of 1.9, use Serializers.Base instead
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 settable properties of a bean: contains both type and name definitions, and reflection-based set functionality.
SettableBeanProperty.FieldProperty	This concrete sub-class implements property that is set directly assigning to a Field.
SettableBeanProperty.InnerClassProperty	This sub-class is used to handle special case of value being a non-static inner class.
SettableBeanProperty.ManagedReferenceProperty	Wrapper property that is used to handle managed (forward) properties (see [JACKSON-235] for more information).
SettableBeanProperty.MethodProperty	This concrete sub-class implements property that is set using regular "setter" method.
SettableBeanProperty.NullProvider	To support [JACKSON-420] we need bit more indirection; this is used to produce artificial failure for primitives that don't accept JSON null as value.
SettableBeanProperty.SetterlessProperty	This concrete sub-class implements Collection or Map property that is indirectly by getting the property value and directly modifying it.
SimpleAbstractTypeResolver	Simple AbstractTypeResolver implementation, which is based on static mapping from abstract super types into sub types (concrete or abstract), but retaining generic parameterization.
SimpleBeanPropertyFilter	Simple BeanPropertyFilter 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).
SimpleModule	Simple Module implementation that allows registration of serializers and deserializers, and bean serializer and deserializer modifiers.
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
SmileBufferRecycler<T>	Simple helper class used for implementing simple reuse system for Smile-specific buffers that are used.
SmileConstants	Constants used by SmileGenerator and SmileParser
SmileFactory	Factory used for constructing SmileParser and SmileGenerator instances; both of which handle Smile encoded data.
SmileGenerator	JsonGenerator implementation for the experimental "Binary JSON Infoset".
SmileGenerator.Feature	Enumeration that defines all togglable features for Smile generators.
SmileGenerator.SharedStringNode	Helper class used for keeping track of possibly shareable String references (for field names and/or short String values)
SmileParser
SmileParser.Feature	Enumeration that defines all togglable features for Smile generators.
SmileParserBootstrapper	Simple bootstrapper version used with Smile format parser.
SmileUtil	Class for miscellaneous helper methods.
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.ArraySerializerBase<T>	Base class for serializers that will output contents as JSON arrays.
StdArraySerializers.BooleanArraySerializer
StdArraySerializers.ByteArraySerializer	Unlike other integral number array serializers, we do not just print out byte values as numbers.
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.StringArraySerializer	Standard serializer used for String[] values.
StdContainerSerializers	Dummy container class to group standard container serializers: serializers that can serialize things like Lists, Maps and such.
StdContainerSerializers.IndexedListSerializer	This is an optimized serializer for Lists that can be efficiently traversed by index (as opposed to others, such as LinkedList that can not}.
StdContainerSerializers.IteratorSerializer
StdDateFormat	Default DateFormat implementation used by standard Date serializers and deserializers.
StdDeserializationContext	Default implementation of DeserializationContext.
StdDeserializer<T>	Base class for common deserializers.
StdDeserializer<T>	Deprecated. Since 1.9, use StdDeserializer instead.
StdDeserializer.BigDecimalDeserializer
StdDeserializer.BigIntegerDeserializer	This is bit trickier to implement efficiently, while avoiding overflow problems.
StdDeserializer.BooleanDeserializer
StdDeserializer.ByteDeserializer
StdDeserializer.CharacterDeserializer
StdDeserializer.DoubleDeserializer
StdDeserializer.FloatDeserializer
StdDeserializer.IntegerDeserializer
StdDeserializer.LongDeserializer
StdDeserializer.NumberDeserializer	For type Number.class, we can just rely on type mappings that plain JsonParser.getNumberValue() returns.
StdDeserializer.PrimitiveOrWrapperDeserializer<T>
StdDeserializer.ShortDeserializer
StdDeserializer.SqlDateDeserializer	Compared to plain old Date, SQL version is easier to deal with: mostly because it is more limited.
StdDeserializer.StackTraceElementDeserializer
StdDeserializer.StringDeserializer	Deprecated. Since 1.9 use StringDeserializer instead.
StdDeserializerProvider	Default DeserializerProvider implementation.
StdDeserializerProvider.WrappedDeserializer	Simple deserializer that will call configured type deserializer, passing in configured data deserializer, and exposing it all as a simple deserializer.
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
StdJdkSerializers.AtomicReferenceSerializer
StdJdkSerializers.ClassSerializer	Also: default bean access will not do much good with Class.class.
StdJdkSerializers.FileSerializer	For now, File objects get serialized by just outputting absolute (but not canonical) name as String value
StdKeyDeserializer	Base class for simple key deserializers.
StdKeyDeserializer	Deprecated. Since 1.9, use StdKeyDeserializer instead.
StdKeyDeserializers	Helper class used to contain simple/well-known key deserializers.
StdKeySerializer	Specialized serializer that can be used as the generic key serializer, when serializing Maps to JSON Objects.
StdKeySerializer	Deprecated. Since 1.9 use StdKeySerializer instead
StdKeySerializers
StdKeySerializers.CalendarKeySerializer
StdKeySerializers.DateKeySerializer
StdKeySerializers.StringKeySerializer
StdScalarDeserializer<T>	Base class for deserializers that handle types that are serialized as JSON scalars (non-structured, i.e.
StdScalarDeserializer<T>	Deprecated. Since 1.9, use StdScalarDeserializer instead.
StdSerializerProvider	Default SerializerProvider implementation.
StdSerializers	Container class for serializers used for handling standard JDK-provided types.
StdSerializers.BooleanSerializer	Serializer used for primitive boolean, as well as java.util.Boolean wrapper type.
StdSerializers.CalendarSerializer	Deprecated. Since 1.9, use DateSerializer instead
StdSerializers.DoubleSerializer	This is the special serializer for regular Doubles (and primitive doubles)
StdSerializers.FloatSerializer
StdSerializers.IntegerSerializer	This is the special serializer for regular Integers (and primitive ints)
StdSerializers.IntLikeSerializer	Similar to StdSerializers.IntegerSerializer, but will not cast to Integer: instead, cast is to Number, and conversion is by calling Number.intValue().
StdSerializers.LongSerializer
StdSerializers.NumberSerializer	As a fallback, we may need to use this serializer for other types of Numbers (custom types).
StdSerializers.SerializableSerializer	Deprecated. Since 1.9, use DateSerializer instead
StdSerializers.SerializableWithTypeSerializer	Deprecated. Since 1.9, use DateSerializer instead
StdSerializers.SqlDateSerializer	Compared to regular StdSerializers.UtilDateSerializer, we do use String representation here.
StdSerializers.SqlTimeSerializer
StdSerializers.StringSerializer	Deprecated. Since 1.9, use StringSerializer instead
StdSerializers.UtilDateSerializer	Deprecated. Since 1.9, use DateSerializer instead
StdSubtypeResolver
StdTypeResolverBuilder	Default TypeResolverBuilder implementation.
StdValueInstantiator	Basic ValueInstantiator implementation, which only supports use of default constructor.
StreamBasedParserBase	Deprecated. Since 1.9, sub-classes should just embed code from here
StringCollectionDeserializer
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 supertypes to subtypes.
TextBuffer	TextBuffer is a class similar to StringBuffer, with following differences: TextBuffer uses segments character arrays, to avoid having to do additional array copies when array is not big enough.
TextNode	Value node that contains a text value.
ThrowableDeserializer	Deserializer that builds on basic BeanDeserializer but override some aspects like instance construction.
ThrowableDeserializer	Deprecated. Since 1.9, use ThrowableDeserializer instead.
TimestampDeserializer	Simple deserializer for handling Timestamp values.
TimeZoneSerializer
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.
TokenBufferSerializer	We also want to directly support serialization of TokenBuffer; and since it is part of core package, it can not implement JsonSerializable (which is only included in the mapper package)
Tool	Simple command-line utility that can be used to encode JSON as Smile, or decode JSON from Smile: direction is indicated by single command-line option of either "-e" (encode) or "-d" (decode).
ToStringSerializer	Simple general purpose serializer, useful for any type for which Object.toString() returns the desired JSON value.
ToStringSerializer	Deprecated. Since 1.9 use ToStringSerializer
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
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
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.
TypeReference<T>	This class is used to pass full generics type information, and avoid problems with type erasure (that basically removes most usable type references from runtime Class objects).
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
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).
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	Deprecated. Since 1.9, use UntypedObjectDeserializer instead.
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
UTF32Reader	Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.
Utf8Generator
Utf8StreamParser	This is a concrete implementation of JsonParser, which is based on a InputStream as the input source.
UTF8Writer
ValueInjector	Class that encapsulates details of value injection that occurs before deserialization of a POJO.
ValueInstantiator	Class that defines simple API implemented by objects that create value instances.
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".
Version	Object that encapsulates version information of a component, and is return by Versioned.version().
Versioned	Interface that those Jackson components that are explicitly versioned will implement.
VersionUtil	Functionality for supporting exposing of component Versions.
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.
WriterBasedGenerator	JsonGenerator that outputs JSON content using a Writer which handles character encoding.
XmlAdapterJsonDeserializer
XmlAdapterJsonSerializer