or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

advanced-features.mdannotations.mdconfiguration.mddeserialization.mdindex.mdjson-tree-model.mdmodules.mdobject-mapping.mdserialization.mdtype-system.md
tile.json

tessl/maven-com-fasterxml-jackson-core--jackson-databind

General data-binding functionality for Jackson: works on core streaming API

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.fasterxml.jackson.core/jackson-databind@2.20.x

To install, run

npx @tessl/cli install tessl/maven-com-fasterxml-jackson-core--jackson-databind@2.20.0

index.mddocs/

Jackson Databind

Jackson Databind provides data-binding functionality for Jackson JSON processing - converts between Java objects and JSON. It works on top of Jackson's core streaming API and provides functionality for reading and writing JSON to/from POJOs (Plain Old Java Objects), a general-purpose JSON Tree Model, and advanced object concepts like polymorphism and object identity.

Package Information

  • Package Name: com.fasterxml.jackson.core/jackson-databind
  • Package Type: maven
  • Language: Java
  • Installation: 
    <dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.20.0</version>
</dependency>

Core Imports

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.JavaType;

Basic Usage

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// Create ObjectMapper instance
ObjectMapper mapper = new ObjectMapper();

// Read JSON from string to POJO
String json = "{\"name\":\"John\", \"age\":30}";
Person person = mapper.readValue(json, Person.class);

// Write POJO to JSON string
String output = mapper.writeValueAsString(person);

// Read JSON as tree model
JsonNode tree = mapper.readTree(json);
String name = tree.get("name").asText();

Architecture

Jackson Databind is built around several key components:

  • ObjectMapper: Main entry point for all JSON processing operations
  • JsonNode: Tree model for representing JSON in memory
  • ObjectReader/ObjectWriter: Builder-style APIs for configured reading/writing
  • JavaType: Type system for handling generic types and collections
  • Serialization Framework: Pluggable serializers for converting objects to JSON
  • Deserialization Framework: Pluggable deserializers for converting JSON to objects
  • Configuration System: Features and settings for customizing behavior
  • Annotation System: Annotations for controlling serialization/deserialization

Capabilities

Object Mapping

Core functionality for reading and writing JSON to/from Java objects, including POJOs, collections, and maps.

public class ObjectMapper extends ObjectCodec implements Versioned, Serializable {
    // Reading methods
    public <T> T readValue(String content, Class<T> valueType) throws JsonProcessingException;
    public <T> T readValue(String content, TypeReference<T> valueTypeRef) throws JsonProcessingException;
    public <T> T readValue(String content, JavaType valueType) throws JsonProcessingException;
    public <T> T readValue(InputStream src, Class<T> valueType) throws IOException, StreamReadException, DatabindException;
    public <T> T readValue(Reader src, Class<T> valueType) throws IOException, StreamReadException, DatabindException;
    public <T> T readValue(URL src, Class<T> valueType) throws IOException, StreamReadException, DatabindException;
    public <T> T readValue(File src, Class<T> valueType) throws IOException, StreamReadException, DatabindException;
    
    // Writing methods
    public String writeValueAsString(Object value) throws JsonProcessingException;
    public byte[] writeValueAsBytes(Object value) throws JsonProcessingException;
    public void writeValue(OutputStream out, Object value) throws IOException, StreamWriteException, DatabindException;
    public void writeValue(Writer w, Object value) throws IOException, StreamWriteException, DatabindException;
    public void writeValue(File resultFile, Object value) throws IOException, StreamWriteException, DatabindException;
    
    // Tree model methods
    public JsonNode readTree(String content) throws JsonProcessingException;
    public JsonNode readTree(InputStream in) throws IOException, StreamReadException, DatabindException;
    public JsonNode readTree(Reader r) throws IOException, StreamReadException, DatabindException;
    public void writeTree(JsonGenerator g, JsonNode rootNode) throws IOException, StreamWriteException, DatabindException;
    
    // Conversion methods
    public <T> T convertValue(Object fromValue, Class<T> toValueType) throws IllegalArgumentException;
    public <T> T convertValue(Object fromValue, TypeReference<T> toValueTypeRef) throws IllegalArgumentException;
    public <T> T convertValue(Object fromValue, JavaType toValueType) throws IllegalArgumentException;
    
    // Factory methods for readers/writers
    public ObjectReader reader();
    public ObjectReader readerFor(Class<?> type);
    public ObjectReader readerFor(JavaType type);
    public ObjectReader readerFor(TypeReference<?> type);
    public ObjectWriter writer();
    public ObjectWriter writerFor(Class<?> type);
    public ObjectWriter writerFor(JavaType type);
    
    // Additional reading methods
    public <T> T readValue(JsonParser p, Class<T> valueType) throws IOException, StreamReadException, DatabindException;
    public <T> T readValue(JsonParser p, TypeReference<T> valueTypeRef) throws IOException, StreamReadException, DatabindException;
    public <T> T readValue(JsonParser p, JavaType valueType) throws IOException, StreamReadException, DatabindException;
    
    // Additional writing methods
    public void writeValue(JsonGenerator g, Object value) throws IOException, StreamWriteException, DatabindException;
    
    // Configuration methods - Core Features
    public ObjectMapper configure(SerializationFeature f, boolean state);
    public ObjectMapper enable(SerializationFeature feature);
    public ObjectMapper enable(SerializationFeature first, SerializationFeature... f);
    public ObjectMapper disable(SerializationFeature feature);
    public ObjectMapper disable(SerializationFeature first, SerializationFeature... f);
    public ObjectMapper configure(DeserializationFeature f, boolean state);
    public ObjectMapper enable(DeserializationFeature feature);
    public ObjectMapper enable(DeserializationFeature first, DeserializationFeature... f);
    public ObjectMapper disable(DeserializationFeature feature);
    public ObjectMapper disable(DeserializationFeature first, DeserializationFeature... f);
    
    // Module registration
    public ObjectMapper registerModule(Module module);
    public ObjectMapper registerModules(Module... modules);
    public ObjectMapper registerModules(Iterable<? extends Module> modules);
    public ObjectMapper findAndRegisterModules();
    
    // Copy methods
    public ObjectMapper copy();
    
    // Key configuration setters
    public ObjectMapper addMixIn(Class<?> target, Class<?> mixinSource);
    public ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s);
    public ObjectMapper setSerializationInclusion(JsonInclude.Include incl);
    public ObjectMapper setVisibility(PropertyAccessor forMethod, JsonAutoDetect.Visibility visibility);
}

Object Mapping

JSON Tree Model

Tree model API for working with JSON as in-memory tree structures, providing DOM-like navigation and manipulation.

public abstract class JsonNode implements TreeNode, Iterable<JsonNode> {
    // Navigation methods
    public abstract JsonNode get(int index);
    public JsonNode get(String fieldName);
    public abstract JsonNode path(String fieldName);
    public abstract JsonNode path(int index);
    public JsonNode at(String jsonPtrExpr);
    public JsonNode at(JsonPointer ptr);
    
    // Type checking methods
    public abstract boolean isArray();
    public abstract boolean isObject();
    public final boolean isValueNode();
    public final boolean isContainerNode();
    public final boolean isMissingNode();
    public boolean isNull();
    public boolean isTextual();
    public boolean isNumber();
    public boolean isBoolean();
    
    // Value extraction methods
    public String asText();
    public String asText(String defaultValue);
    public int asInt();
    public int asInt(int defaultValue);
    public long asLong();
    public long asLong(long defaultValue);
    public double asDouble();
    public double asDouble(double defaultValue);
    public boolean asBoolean();
    public boolean asBoolean(boolean defaultValue);
    
    // Raw value getters
    public String textValue();
    public byte[] binaryValue() throws IOException;
    public boolean booleanValue();
    public Number numberValue();
    public short shortValue();
    public int intValue();
    public long longValue();
    public float floatValue();
    public double doubleValue();
    public BigDecimal decimalValue();
    public BigInteger bigIntegerValue();
    
    // Additional type checking methods
    public boolean isShort();
    public boolean isInt();
    public boolean isLong();
    public boolean isFloat();
    public boolean isDouble();
    public boolean isBigDecimal();
    public boolean isBigInteger();
    public boolean isIntegralNumber();
    public boolean isFloatingPointNumber();
    public final boolean isPojo();
    
    // Field/value existence checking
    public boolean has(String fieldName);
    public boolean has(int index);
    public boolean hasNonNull(String fieldName);
    public boolean hasNonNull(int index);
    
    // Tree search methods
    public abstract JsonNode findValue(String fieldName);
    public final List<JsonNode> findValues(String fieldName);
    public final List<String> findValuesAsText(String fieldName);
    public abstract JsonNode findParent(String fieldName);
    public final List<JsonNode> findParents(String fieldName);
    
    // Tree modification methods
    public abstract <T extends JsonNode> T deepCopy();
    public JsonNode withObject(JsonPointer ptr);
    public JsonNode withObject(String expr);
    public JsonNode withObjectProperty(String propertyName);
    public JsonNode withArray(JsonPointer ptr);
    public JsonNode withArray(String expr);
    public JsonNode withArrayProperty(String propertyName);
    
    // Container methods
    public abstract int size();
    public abstract boolean isEmpty();
    public Iterator<String> fieldNames();
    public Iterator<Map.Entry<String, JsonNode>> fields();
    public Iterator<JsonNode> elements();
}

JSON Tree Model

Type System

Type representation system for handling generic types, collections, and complex type hierarchies safely.

public abstract class JavaType extends ResolvedType implements Serializable {
    // Type inspection
    public abstract Class<?> getRawClass();
    public abstract boolean hasRawClass(Class<?> clz);
    public final boolean hasRawClass(Class<?> clz);
    public final boolean isTypeOrSubTypeOf(Class<?> clz);
    public final boolean isTypeOrSuperTypeOf(Class<?> clz);
    public abstract boolean isArrayType();
    public abstract boolean isCollectionLikeType();
    public abstract boolean isMapLikeType();
    public abstract boolean hasContentType();
    public boolean isAbstract();
    public boolean isConcrete();
    public boolean isThrowable();
    public final boolean isEnumType();
    public final boolean isRecordType();
    public boolean isPrimitive();
    public final boolean isFinal();
    
    // Generic type handling
    public abstract JavaType getContentType();
    public abstract JavaType getKeyType();
    public abstract int containedTypeCount();
    public abstract JavaType containedType(int index);
    public abstract String containedTypeName(int index);
    public abstract TypeBindings getBindings();
    public abstract JavaType getSuperClass();
    public abstract List<JavaType> getInterfaces();
    public abstract JavaType[] findSuperTypes(Class<?> erasedTarget);
    public abstract JavaType findTypeParameters(Class<?> expType);
    
    // Type manipulation
    public abstract JavaType withContentType(JavaType contentType);
    public JavaType withTypeHandler(Object h);
    public JavaType withContentTypeHandler(Object h);
    public JavaType withValueHandler(Object h);
    public JavaType withContentValueHandler(Object h);
    public JavaType withHandlersFrom(JavaType src);
    public abstract JavaType refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces);
    public JavaType forcedNarrowBy(Class<?> subclass);
    
    // Factory access
    public static JavaType constructType(Type type);
}

Type System

Serialization

Framework for converting Java objects to JSON with customizable serializers and configuration.

public abstract class JsonSerializer<T> {
    // Core serialization
    public abstract void serialize(T value, JsonGenerator gen, SerializerProvider serializers) throws IOException;
    public void serializeWithType(T value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException;
    
    // Metadata methods
    public Class<T> handledType();
    public boolean isEmpty(SerializerProvider provider, T value);
    public boolean usesObjectId();
    
    // Contextual serialization
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException;
    
    // Schema support
    public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType type) throws JsonMappingException;
}

Serialization

Deserialization

Framework for converting JSON to Java objects with customizable deserializers and configuration.

public abstract class JsonDeserializer<T> {
    // Core deserialization
    public abstract T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException;
    public T deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException;
    
    // Null and empty value handling
    public T getNullValue(DeserializationContext ctxt) throws JsonMappingException;
    public T getEmptyValue(DeserializationContext ctxt) throws JsonMappingException;
    public AccessPattern getNullAccessPattern();
    public AccessPattern getEmptyAccessPattern();
    
    // Metadata methods
    public Class<?> handledType();
    public boolean isCachable();
    public ObjectIdReader getObjectIdReader();
    
    // Contextual deserialization
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException;
}

Deserialization

Configuration

Configuration system for customizing Jackson behavior through features, settings, and overrides.

public enum SerializationFeature implements ConfigFeature {
    WRAP_ROOT_VALUE,
    INDENT_OUTPUT,
    FAIL_ON_EMPTY_BEANS,
    FAIL_ON_SELF_REFERENCES,
    WRAP_EXCEPTIONS,
    FAIL_ON_UNWRAPPED_TYPE_IDENTIFIERS,
    WRITE_SELF_REFERENCES_AS_NULL,
    CLOSE_CLOSEABLE,
    FLUSH_AFTER_WRITE_VALUE,
    WRITE_DATES_AS_TIMESTAMPS,
    WRITE_DATE_KEYS_AS_TIMESTAMPS,
    WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,
    WRITE_ENUMS_USING_TO_STRING,
    WRITE_ENUMS_USING_INDEX,
    WRITE_ENUM_KEYS_USING_INDEX,
    WRITE_NULL_MAP_VALUES,
    WRITE_EMPTY_JSON_ARRAYS,
    WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED,
    WRITE_BIGDECIMAL_AS_PLAIN,
    WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS,
    ORDER_MAP_ENTRIES_BY_KEYS,
    USE_EQUALITY_FOR_OBJECT_ID,
    WRITE_DATES_WITH_ZONE_ID,
    WRITE_DATES_WITH_CONTEXT_TIME_ZONE,
    WRITE_DURATIONS_AS_TIMESTAMPS,
    FAIL_ON_ORDER_MAP_BY_INCOMPARABLE_KEY,
    EAGER_SERIALIZER_FETCH;
    
    public boolean enabledByDefault();
    public int getMask();
    public boolean enabledIn(int flags);
}

public enum DeserializationFeature implements ConfigFeature {
    USE_BIG_DECIMAL_FOR_FLOATS,
    USE_BIG_INTEGER_FOR_INTS,
    USE_LONG_FOR_INTS,
    USE_JAVA_ARRAY_FOR_JSON_ARRAY,
    FAIL_ON_UNKNOWN_PROPERTIES,
    FAIL_ON_NULL_FOR_PRIMITIVES,
    FAIL_ON_NUMBERS_FOR_ENUMS,
    FAIL_ON_INVALID_SUBTYPE,
    FAIL_ON_READING_DUP_TREE_KEY,
    FAIL_ON_IGNORED_PROPERTIES,
    FAIL_ON_UNRESOLVED_OBJECT_IDS,
    FAIL_ON_MISSING_CREATOR_PROPERTIES,
    FAIL_ON_NULL_CREATOR_PROPERTIES,
    FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY,
    FAIL_ON_TRAILING_TOKENS,
    WRAP_EXCEPTIONS,
    ACCEPT_SINGLE_VALUE_AS_ARRAY,
    UNWRAP_SINGLE_VALUE_ARRAYS,
    UNWRAP_ROOT_VALUE,
    ACCEPT_EMPTY_STRING_AS_NULL_OBJECT,
    ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT,
    ACCEPT_FLOAT_AS_INT,
    READ_ENUMS_USING_TO_STRING,
    READ_UNKNOWN_ENUM_VALUES_AS_NULL,
    READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE,
    READ_DATE_TIMESTAMPS_AS_NANOSECONDS,
    ADJUST_DATES_TO_CONTEXT_TIME_ZONE,
    EAGER_DESERIALIZER_FETCH,
    FAIL_ON_SUBTYPE_CLASS_NOT_REGISTERED,
    FAIL_ON_UNEXPECTED_VIEW_PROPERTIES,
    FAIL_ON_UNKNOWN_INJECT_VALUE;
    
    public boolean enabledByDefault();
    public int getMask();  
    public boolean enabledIn(int flags);
}

Configuration

Annotations

Jackson databind annotations for controlling serialization and deserialization behavior.

@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonSerialize {
    Class<? extends JsonSerializer> using() default JsonSerializer.None.class;
    Class<? extends JsonSerializer> contentUsing() default JsonSerializer.None.class;
    Class<? extends JsonSerializer> keyUsing() default JsonSerializer.None.class;
    Class<? extends JsonSerializer> nullsUsing() default JsonSerializer.None.class;
    Class<?> as() default Void.class;
    Class<?> keyAs() default Void.class;
    Class<?> contentAs() default Void.class;
    JsonSerialize.Inclusion include() default JsonSerialize.Inclusion.DEFAULT_INCLUSION;
    JsonSerialize.Typing typing() default JsonSerialize.Typing.DEFAULT_TYPING;
    
    public enum Inclusion {
        ALWAYS, NON_NULL, NON_ABSENT, NON_EMPTY, NON_DEFAULT, CUSTOM, USE_DEFAULTS;
    }
    
    public enum Typing {
        DYNAMIC, STATIC, DEFAULT_TYPING;
    }
}

@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonDeserialize {
    Class<? extends JsonDeserializer> using() default JsonDeserializer.None.class;
    Class<? extends JsonDeserializer> contentUsing() default JsonDeserializer.None.class;
    Class<? extends JsonDeserializer> keyUsing() default KeyDeserializer.None.class;
    Class<?> builder() default Void.class;
    Class<?> as() default Void.class;
    Class<?> keyAs() default Void.class;
    Class<?> contentAs() default Void.class;
    Class<? extends Converter> converter() default Converter.None.class;
    Class<? extends Converter> contentConverter() default Converter.None.class;
}

// Additional important annotations
@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonPOJOBuilder {
    String buildMethodName() default "build";
    String withPrefix() default "with";
}

@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonNaming {
    Class<? extends PropertyNamingStrategy> value();
}

@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonAppend {
    JsonAppend.Attr[] attrs() default {};
    JsonAppend.Prop[] props() default {};
    boolean prepend() default false;
    
    public @interface Attr {
        String value();
        boolean required() default false;
    }
    
    public @interface Prop {
        Class<? extends VirtualBeanPropertyWriter> value();
        String name() default "";
        String namespace() default "";
        Class<?> type() default Object.class;
        int index() default -1;
        boolean required() default false;
    }
}

Annotations

Modules

Module system for extending ObjectMapper functionality with additional serializers, deserializers, and features.

public abstract class Module implements Versioned {
    // Module metadata
    public abstract String getModuleName();
    public abstract Version version();
    
    // Module setup
    public abstract void setupModule(SetupContext context);
    
    // Setup context interface
    public static interface SetupContext {
        // Configuration access
        MapperConfig<?> getConfig();
        DeserializationConfig getDeserializationConfig();
        SerializationConfig getSerializationConfig();
        
        // Registration methods
        void addDeserializers(Deserializers d);
        void addKeyDeserializers(KeyDeserializers d);
        void addSerializers(Serializers s);
        void addKeySerializers(Serializers s);
        void addBeanDeserializerModifier(BeanDeserializerModifier mod);
        void addBeanSerializerModifier(BeanSerializerModifier mod);
        void addAbstractTypeResolver(AbstractTypeResolver resolver);
        void addTypeModifier(TypeModifier modifier);
        void addValueInstantiators(ValueInstantiators instantiators);
        void setClassIntrospector(ClassIntrospector ci);
        void insertAnnotationIntrospector(AnnotationIntrospector ai);
        void appendAnnotationIntrospector(AnnotationIntrospector ai);
        void registerSubtypes(Class<?>... subtypes);
        void registerSubtypes(NamedType... subtypes);
        void registerSubtypes(Collection<Class<?>> subtypes);
        void setMixInAnnotations(Class<?> target, Class<?> mixinSource);
        void addDeserializationProblemHandler(DeserializationProblemHandler handler);
        void setNamingStrategy(PropertyNamingStrategy naming);
    }
}

Modules

Advanced Features

Advanced features including polymorphism, custom type handling, and object identity management.

// Polymorphic type handling
public abstract class TypeResolverBuilder<T extends TypeResolverBuilder<T>> {
    public abstract T inclusion(JsonTypeInfo.As includeAs);
    public abstract T typeProperty(String propName);
    public abstract T typeIdVisibility(boolean isVisible);
    public abstract T defaultImpl(Class<?> defaultImpl);
    public abstract TypeSerializer buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes);
    public abstract TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes);
}

// Injectable values for dependency injection
public abstract class InjectableValues {
    public abstract Object findInjectableValue(Object valueId, DeserializationContext ctxt, BeanProperty forProperty, Object beanInstance) throws JsonMappingException;
    
    public static class Std extends InjectableValues implements Serializable {
        public Std();
        public Std(Map<String, Object> values);
        public Std addValue(String key, Object value);
        public Std addValue(Class<?> key, Object value);
    }
}

// Object identity support
@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonIdentityInfo {
    Class<? extends ObjectIdGenerator> generator();
    String property() default "@id";
    boolean resolver() default false;
    Class<? extends ObjectIdResolver> resolver() default ObjectIdResolver.class;
    Class<?> scope() default Object.class;
}

Advanced Features

Types

// Core exception types
public class JsonProcessingException extends IOException {
    public JsonProcessingException(String msg);
    public JsonProcessingException(String msg, Throwable rootCause);
    public JsonProcessingException(String msg, JsonLocation loc);
    public JsonProcessingException(String msg, JsonLocation loc, Throwable rootCause);
    public String getOriginalMessage();
    public Object getProcessor();
    public JsonLocation getLocation();
}

public class JsonMappingException extends DatabindException {
    public static class Reference implements Serializable {
        public Reference();
        public Reference(Object from);
        public Reference(Object from, String fieldName);
        public Reference(Object from, int index);
        public void setFrom(Object o);
        public void setFieldName(String fieldName);
        public void setIndex(int index);
        public Object getFrom();
        public String getFieldName();
        public int getIndex();
    }
    
    public List<Reference> getPath();
    public String getPathReference();
    public void prependPath(Object referrer, String fieldName);
    public void prependPath(Object referrer, int index);
    public void prependPath(Reference r);
    
    public static JsonMappingException from(JsonParser p, String msg);
    public static JsonMappingException from(JsonParser p, String msg, Throwable problem);
    public static JsonMappingException from(JsonGenerator g, String msg);
    public static JsonMappingException from(JsonGenerator g, String msg, Throwable problem);
    public static JsonMappingException from(DeserializationContext ctxt, String msg);
    public static JsonMappingException from(DeserializationContext ctxt, String msg, Throwable t);
    public static JsonMappingException from(SerializerProvider ctxt, String msg);
    public static JsonMappingException from(SerializerProvider ctxt, String msg, Throwable problem);
}

// Specific exception types
public class MismatchedInputException extends JsonMappingException {
    public MismatchedInputException(JsonParser p, String msg);
    public MismatchedInputException(JsonParser p, String msg, JsonLocation loc);
    public MismatchedInputException(JsonParser p, String msg, Class<?> targetType);
    public MismatchedInputException(JsonParser p, String msg, JavaType targetType);
    public Class<?> getTargetType();
}

public class InvalidDefinitionException extends JsonMappingException {
    public InvalidDefinitionException(JsonParser p, String msg, BeanDescription beanDesc);
    public InvalidDefinitionException(JsonParser p, String msg, JavaType type);
    public JavaType getType();
}

public class InvalidFormatException extends MismatchedInputException {
    public InvalidFormatException(JsonParser p, String msg, Object value, Class<?> targetType);
    public Object getValue();
}

public class UnrecognizedPropertyException extends PropertyBindingException {
    public UnrecognizedPropertyException(JsonParser p, String msg, JsonLocation loc, Class<?> referringClass, String propName, Collection<Object> propertyIds);
    public Collection<Object> getKnownPropertyIds();
}

public class IgnoredPropertyException extends PropertyBindingException {
    public IgnoredPropertyException(JsonParser p, String msg, JsonLocation loc, Class<?> referringClass, String propName, Collection<Object> propertyIds);
}

public abstract class PropertyBindingException extends JsonMappingException {
    public String getPropertyName();
    public Class<?> getReferringClass();
}

public class InvalidNullException extends MismatchedInputException {
    public InvalidNullException(DeserializationContext ctxt, String msg, JsonLocation loc);
}

public class ValueInstantiationException extends JsonMappingException {
    public ValueInstantiationException(JsonParser p, String msg, JavaType type);
    public ValueInstantiationException(JsonParser p, String msg, JavaType type, Throwable cause);
    public JavaType getType();
}

// Property naming
public class PropertyName implements Serializable {
    public static final PropertyName USE_DEFAULT;
    public static final PropertyName NO_NAME;
    
    public PropertyName(String simpleName);
    public PropertyName(String simpleName, String namespace);
    public static PropertyName construct(String simpleName);
    public static PropertyName construct(String simpleName, String ns);
    
    public String getSimpleName();
    public String getNamespace();
    public boolean hasSimpleName();
    public boolean hasNamespace();
    
    public PropertyName withSimpleName(String simpleName);
    public PropertyName withNamespace(String ns);
    public PropertyName internSimpleName();
}

// Configuration features interface
public interface ConfigFeature {
    boolean enabledByDefault();
    int getMask();
    boolean enabledIn(int flags);
}

// Access pattern enumeration
public enum AccessPattern {
    ALWAYS_NULL,
    CONSTANT,
    DYNAMIC,
    READ_ONLY,
    WRITE_ONLY;
}