diff --git a/aom/src/main/java/com/nedap/archie/aom/ResourceDescription.java b/aom/src/main/java/com/nedap/archie/aom/ResourceDescription.java
index 0794e4943..632202cba 100644
--- a/aom/src/main/java/com/nedap/archie/aom/ResourceDescription.java
+++ b/aom/src/main/java/com/nedap/archie/aom/ResourceDescription.java
@@ -3,7 +3,6 @@
 import com.fasterxml.jackson.annotation.JsonAlias;
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 import com.fasterxml.jackson.annotation.JsonSetter;
-import com.fasterxml.jackson.databind.JsonNode;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
@@ -102,22 +101,21 @@ public void setLifecycleState(String lifecycleState) {
      *
      * This deserializer ensures backward compatibility by accepting both formats
      * and always setting the lifecycle state value as a plain String.
+     * Object parameter instead of JsonNode keeps this compatible with both Jackson 2 and 3.
      */
     @JsonSetter("lifecycle_state")
-    private void setLifecycleState(JsonNode node) {
-        if (node == null || node.isNull()) {
+    private void setLifecycleState(Object node) {
+        if (node == null) {
+            this.lifecycleState = null;
+        } else if (node instanceof String) {
+            this.lifecycleState = (String) node;
+        } else if (node instanceof Map) {
+            Object codeString = ((Map<?, ?>) node).get("code_string");
+            this.lifecycleState = (codeString != null) ? codeString.toString() : null;
+        } else {
+            // Empty list or other unexpected type: treat as absent
             this.lifecycleState = null;
-            return;
-        }
-
-        if (node.isTextual()) {
-            this.lifecycleState = node.asText();
-            return;
         }
-
-        JsonNode codeString = node.get("code_string");
-
-        this.lifecycleState = (codeString != null && !codeString.isNull()) ? codeString.asText() : null;
     }
 
     public String getCustodianNamespace() {
diff --git a/aom/src/main/java/com/nedap/archie/rules/ExpressionType.java b/aom/src/main/java/com/nedap/archie/rules/ExpressionType.java
index 0c3f6f986..6a4e704e3 100644
--- a/aom/src/main/java/com/nedap/archie/rules/ExpressionType.java
+++ b/aom/src/main/java/com/nedap/archie/rules/ExpressionType.java
@@ -1,5 +1,7 @@
 package com.nedap.archie.rules;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
+
 /**
  * TODO: this should contain all primitive types and primitive types should be merged into this
  * Created by pieter.bos on 27/10/15.
@@ -7,6 +9,7 @@
 public enum ExpressionType {
      BOOLEAN, STRING, INTEGER, REAL, DATE, TIME, DATETIME, DURATION, C_STRING;
 
+    @JsonCreator
     public static ExpressionType fromString(String string) {
         switch(string) {
             case "Boolean":
@@ -28,30 +31,26 @@ public static ExpressionType fromString(String string) {
             case "CString":
                 return C_STRING;
         }
+        // Fall back to case-insensitive match against enum constant names (e.g. "C_STRING")
+        for (ExpressionType type : values()) {
+            if (type.name().equalsIgnoreCase(string)) {
+                return type;
+            }
+        }
         return null;
     }
 
     public String toString() {
-        switch(this) {
-            case BOOLEAN:
-                return "Boolean";
-            case STRING:
-                return "String";
-            case INTEGER:
-                return "Integer";
-            case REAL:
-                return "Real";
-            case DATE:
-                return "Date";
-            case TIME:
-                return "Time";
-            case DATETIME:
-                return "DateTime";
-            case DURATION:
-                return "Duration";
-            case C_STRING:
-                return "CString";
-        }
-        return null;
+        return switch (this) {
+            case BOOLEAN -> "Boolean";
+            case STRING -> "String";
+            case INTEGER -> "Integer";
+            case REAL -> "Real";
+            case DATE -> "Date";
+            case TIME -> "Time";
+            case DATETIME -> "DateTime";
+            case DURATION -> "Duration";
+            case C_STRING -> "CString";
+        };
     }
 }
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializer.java
index 490936fe8..b5554ed10 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializer.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializer.java
@@ -4,6 +4,7 @@
 import com.nedap.archie.rminfo.RMObjectMapperProvider;
 
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * @author markopi
@@ -12,17 +13,23 @@ abstract public class ADLArchetypeSerializer<T extends Archetype> {
     protected final T archetype;
     final RMObjectMapperProvider rmObjectMapperProvider;
     Function<String, Archetype> flatArchetypeProvider;
-    protected final ADLStringBuilder builder = new ADLStringBuilder();
+    protected final ADLStringBuilder builder;
 
     private final ADLDefinitionSerializer definitionSerializer;
     private final ADLRulesSerializer rulesSerializer;
 
 
+    // Default constructor — uses the Jackson 2 backed ADLStringBuilder.
     protected ADLArchetypeSerializer(T archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider) {
+        this(archetype, flatArchetypeProvider, rmObjectMapperProvider, new ADLStringBuilder());
+    }
+
+    // Use this constructor to supply a custom ADLStringBuilder, e.g. new ADLStringBuilder3() for Jackson 3.
+    protected ADLArchetypeSerializer(T archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, ADLStringBuilder builder) {
         this.archetype = archetype;
         this.flatArchetypeProvider = flatArchetypeProvider;
         this.rmObjectMapperProvider = rmObjectMapperProvider;
-
+        this.builder = builder;
         this.definitionSerializer = new ADLDefinitionSerializer(builder, flatArchetypeProvider, rmObjectMapperProvider);
         this.rulesSerializer = new ADLRulesSerializer(builder, definitionSerializer);
     }
@@ -51,6 +58,23 @@ public static String serialize(Archetype archetype, Function<String, Archetype>
     }
 
 
+    /**
+     * Serialize the archetype to ADL, using a custom ADLStringBuilder (e.g. one backed by Jackson 3).
+     */
+    public static String serialize(Archetype archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, Supplier<ADLStringBuilder> builderSupplier) {
+        if (archetype instanceof Template) {
+            return new ADLTemplateSerializer((Template) archetype, flatArchetypeProvider, rmObjectMapperProvider, builderSupplier.get()).serialize();
+        } else if (archetype instanceof OperationalTemplate) {
+            return new ADLOperationalTemplateSerializer((OperationalTemplate) archetype, flatArchetypeProvider, rmObjectMapperProvider, builderSupplier.get()).serialize();
+        } else if (archetype instanceof TemplateOverlay) {
+            return new ADLTemplateOverlaySerializer((TemplateOverlay) archetype, flatArchetypeProvider, rmObjectMapperProvider, builderSupplier.get()).serialize();
+        } else if (archetype instanceof AuthoredArchetype) {
+            return new ADLAuthoredArchetypeSerializer<>((AuthoredArchetype) archetype, flatArchetypeProvider, rmObjectMapperProvider, builderSupplier.get()).serialize();
+        }
+        throw new AssertionError("Could not serialize archetype of class " +
+                (archetype == null ? null : archetype.getClass().getName()));
+    }
+
     /**
      * Serialize the archetype to ADL
      * @param archetype the archetype to serialize
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLAuthoredArchetypeSerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLAuthoredArchetypeSerializer.java
index 63c5ab41c..f13fdf37c 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLAuthoredArchetypeSerializer.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLAuthoredArchetypeSerializer.java
@@ -16,10 +16,16 @@
  */
 public class ADLAuthoredArchetypeSerializer<T extends AuthoredArchetype> extends ADLArchetypeSerializer<T> {
 
+    // Default constructor — uses the Jackson 2 backed ADLStringBuilder.
     public ADLAuthoredArchetypeSerializer(T archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider) {
         super(archetype, flatArchetypeProvider, rmObjectMapperProvider);
     }
 
+    // Use this constructor to supply a custom ADLStringBuilder, e.g. new ADLStringBuilder3() for Jackson 3.
+    public ADLAuthoredArchetypeSerializer(T archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, ADLStringBuilder builder) {
+        super(archetype, flatArchetypeProvider, rmObjectMapperProvider, builder);
+    }
+
     @Override
     protected void appendLanguage() {
         if (archetype.getOriginalLanguage() == null) return;
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLOperationalTemplateSerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLOperationalTemplateSerializer.java
index d47753c8b..4e9cb1547 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLOperationalTemplateSerializer.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLOperationalTemplateSerializer.java
@@ -11,10 +11,16 @@
  */
 class ADLOperationalTemplateSerializer extends ADLAuthoredArchetypeSerializer<OperationalTemplate> {
 
+    // Default constructor — uses the Jackson 2 backed ADLStringBuilder.
     public ADLOperationalTemplateSerializer(OperationalTemplate archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider) {
         super(archetype, flatArchetypeProvider, rmObjectMapperProvider);
     }
 
+    // Use this constructor to supply a custom ADLStringBuilder, e.g. new ADLStringBuilder3() for Jackson 3.
+    public ADLOperationalTemplateSerializer(OperationalTemplate archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, ADLStringBuilder builder) {
+        super(archetype, flatArchetypeProvider, rmObjectMapperProvider, builder);
+    }
+
     @Override
     protected String serialize() {
         super.serialize();
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLStringBuilder.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLStringBuilder.java
index 39ec6c218..b00a497a2 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLStringBuilder.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLStringBuilder.java
@@ -55,7 +55,7 @@ public ADLStringBuilder indent() {
 
     public ADLStringBuilder odin(Object structure) {
         try {
-            // Pass the current ident depth to the ODINPrettyPrinter
+            // Pass the current indent depth to the ODINPrettyPrinter
             ObjectWriter objectWriter = odinMapper.writer().with(new ODINPrettyPrinter(builder.getIndentDepth()));
 
             String odin = objectWriter.writeValueAsString(structure).trim();
@@ -138,8 +138,4 @@ public int getIndentDepth() {
         return builder.getIndentDepth();
     }
 
-    public ODINMapper getOdinMapper() {
-        return odinMapper;
-    }
 }
-
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateOverlaySerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateOverlaySerializer.java
index 97e4243d3..739f2c40a 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateOverlaySerializer.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateOverlaySerializer.java
@@ -12,10 +12,16 @@
 class ADLTemplateOverlaySerializer extends ADLArchetypeSerializer<TemplateOverlay> {
 
 
+    // Default constructor — uses the Jackson 2 backed ADLStringBuilder.
     public ADLTemplateOverlaySerializer(TemplateOverlay archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider) {
         super(archetype, flatArchetypeProvider, rmObjectMapperProvider);
     }
 
+    // Use this constructor to supply a custom ADLStringBuilder, e.g. new ADLStringBuilder3() for Jackson 3.
+    public ADLTemplateOverlaySerializer(TemplateOverlay archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, ADLStringBuilder builder) {
+        super(archetype, flatArchetypeProvider, rmObjectMapperProvider, builder);
+    }
+
     @Override
     protected String headTag() {
         return "template_overlay";
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateSerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateSerializer.java
index 197d9682a..86f5610f2 100644
--- a/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateSerializer.java
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/ADLTemplateSerializer.java
@@ -12,10 +12,16 @@
  */
 class ADLTemplateSerializer extends ADLAuthoredArchetypeSerializer<Template> {
 
+    // Default constructor — uses the Jackson 2 backed ADLStringBuilder.
     public ADLTemplateSerializer(Template archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider) {
         super(archetype, flatArchetypeProvider, rmObjectMapperProvider);
     }
 
+    // Use this constructor to supply a custom ADLStringBuilder, e.g. new ADLStringBuilder3() for Jackson 3.
+    public ADLTemplateSerializer(Template archetype, Function<String, Archetype> flatArchetypeProvider, RMObjectMapperProvider rmObjectMapperProvider, ADLStringBuilder builder) {
+        super(archetype, flatArchetypeProvider, rmObjectMapperProvider, builder);
+    }
+
     @Override
     protected String headTag() {
         return "template";
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ADLStringBuilder3.java b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ADLStringBuilder3.java
new file mode 100644
index 000000000..79ee536d1
--- /dev/null
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ADLStringBuilder3.java
@@ -0,0 +1,31 @@
+package com.nedap.archie.serializer.adl.jackson3;
+
+import com.nedap.archie.serializer.adl.ADLStringBuilder;
+import org.openehr.odin.jackson3.ODINMapper3;
+import org.openehr.odin.jackson3.ODINPrettyPrinter3;
+
+/**
+ * Jackson 3 variant of {@link ADLStringBuilder}.
+ * Identical behaviour, but uses ODINMapper3 for ODIN serialization instead of the Jackson 2 ODINMapper.
+ */
+public class ADLStringBuilder3 extends ADLStringBuilder {
+
+    private final ODINMapper3 odinMapper;
+
+    public ADLStringBuilder3() {
+        odinMapper = (ODINMapper3) new ArchetypeODINMapperFactory3().createMapper();
+    }
+
+    @Override
+    public ADLStringBuilder odin(Object structure) {
+        try {
+            String odin = odinMapper.writer()
+                    .with(new ODINPrettyPrinter3(getIndentDepth()))
+                    .writeValueAsString(structure).trim();
+            append(odin).newline();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        return this;
+    }
+}
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeODINMapperFactory3.java b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeODINMapperFactory3.java
new file mode 100644
index 000000000..50b5308bc
--- /dev/null
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeODINMapperFactory3.java
@@ -0,0 +1,24 @@
+package com.nedap.archie.serializer.adl.jackson3;
+
+import com.nedap.archie.aom.terminology.ArchetypeTerm;
+import com.nedap.archie.aom.terminology.ArchetypeTerminology;
+import com.nedap.archie.serializer.adl.jackson.ArchetypeTerminologyMixin;
+import org.openehr.odin.jackson3.ODINMapper3;
+import tools.jackson.databind.MapperFeature;
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.module.SimpleModule;
+
+public class ArchetypeODINMapperFactory3 {
+
+    public ObjectMapper createMapper() {
+        SimpleModule module = new SimpleModule("archetype-odin-module");
+        module.addSerializer(ArchetypeTerm.class, new ArchetypeTermOdinSerializer());
+        module.setMixInAnnotation(ArchetypeTerminology.class, ArchetypeTerminologyMixin.class);
+
+        return ODINMapper3.builder()
+                .deactivateDefaultTyping()
+                .disable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY)
+                .addModule(module)
+                .build();
+    }
+}
diff --git a/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeTermOdinSerializer.java b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeTermOdinSerializer.java
new file mode 100644
index 000000000..9d8abc266
--- /dev/null
+++ b/aom/src/main/java/com/nedap/archie/serializer/adl/jackson3/ArchetypeTermOdinSerializer.java
@@ -0,0 +1,31 @@
+package com.nedap.archie.serializer.adl.jackson3;
+
+import com.nedap.archie.aom.terminology.ArchetypeTerm;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+import java.util.Map;
+
+/**
+ * ArchetypeTerm implements Map, so gets serialized with the Mapserializer instead of object. Do this manually
+ */
+public class ArchetypeTermOdinSerializer extends ValueSerializer<ArchetypeTerm> {
+
+    @Override
+    public void serialize(ArchetypeTerm value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeStartObject();
+        gen.writeName("text");
+        gen.writeString(value.getText());
+        if (value.getDescription() != null) {
+            gen.writeName("description");
+            gen.writeString(value.getDescription());
+        }
+        for (Map.Entry<String, String> entry : value.getOtherItems().entrySet()) {
+            gen.writeName(entry.getKey());
+            gen.writeString(entry.getValue());
+        }
+        gen.writeEndObject();
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json/RulesSectionMixin.java b/archie-utils/src/main/java/com/nedap/archie/json/RulesSectionMixin.java
index de6c8d5ef..830cc5439 100644
--- a/archie-utils/src/main/java/com/nedap/archie/json/RulesSectionMixin.java
+++ b/archie-utils/src/main/java/com/nedap/archie/json/RulesSectionMixin.java
@@ -1,8 +1,7 @@
 package com.nedap.archie.json;
 
-import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-
-@JsonSerialize(converter = RulesSectionToListConverter.class)
+@com.fasterxml.jackson.databind.annotation.JsonSerialize(converter = RulesSectionToListConverter.class)
+@tools.jackson.databind.annotation.JsonSerialize(converter = com.nedap.archie.json3.RulesSectionToListConverter.class)
 public interface RulesSectionMixin {
 
 }
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/ArchieDurationModule.java b/archie-utils/src/main/java/com/nedap/archie/json3/ArchieDurationModule.java
new file mode 100644
index 000000000..4065af275
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/ArchieDurationModule.java
@@ -0,0 +1,26 @@
+package com.nedap.archie.json3;
+
+import org.threeten.extra.PeriodDuration;
+import tools.jackson.databind.module.SimpleModule;
+
+import java.time.Duration;
+import java.time.Period;
+import java.time.temporal.TemporalAmount;
+
+/**
+ * A Jackson module that overrides the standard JavaTimeModule serializers and deserializers for ISO 8601 Durations.
+ * It supports the negative format as used in OpenEHR, and it can parse PeriodDurations if required
+ */
+public class ArchieDurationModule extends SimpleModule {
+
+    public ArchieDurationModule() {
+        super("archie-duration-module");
+
+        addDeserializer(TemporalAmount.class, new DurationDeserializer());
+
+        addSerializer(Duration.class, new DurationSerializer());
+        addSerializer(TemporalAmount.class, new DurationSerializer());
+        addSerializer(Period.class, new DurationSerializer());
+        addSerializer(PeriodDuration.class, new DurationSerializer());
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/ArchieTypeResolverBuilder3.java b/archie-utils/src/main/java/com/nedap/archie/json3/ArchieTypeResolverBuilder3.java
new file mode 100644
index 000000000..bb0cc125f
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/ArchieTypeResolverBuilder3.java
@@ -0,0 +1,50 @@
+package com.nedap.archie.json3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import tools.jackson.databind.DefaultTyping;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import tools.jackson.databind.jsontype.impl.DefaultTypeResolverBuilder;
+import com.nedap.archie.aom.RulesSection;
+import com.nedap.archie.base.OpenEHRBase;
+import com.nedap.archie.rminfo.ArchieAOMInfoLookup;
+import com.nedap.archie.rminfo.ArchieRMInfoLookup;
+import com.nedap.archie.rminfo.RMTypeInfo;
+import com.nedap.archie.json.ArchieJacksonConfiguration;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Jackson 3 port of {@link com.nedap.archie.json.ArchieTypeResolverBuilder}.
+ */
+public class ArchieTypeResolverBuilder3 extends DefaultTypeResolverBuilder {
+
+    private final Set<Class<?>> classesToNotAddTypeProperty;
+
+    public ArchieTypeResolverBuilder3(ArchieJacksonConfiguration configuration) {
+        super(BasicPolymorphicTypeValidator.builder().allowIfBaseType(OpenEHRBase.class).build(),
+                DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
+        classesToNotAddTypeProperty = new HashSet<>();
+        if (!configuration.isAlwaysIncludeTypeProperty()) {
+            List<RMTypeInfo> allTypes = new ArrayList<>(ArchieRMInfoLookup.getInstance().getAllTypes());
+            allTypes.addAll(ArchieAOMInfoLookup.getInstance().getAllTypes());
+            for (RMTypeInfo type : allTypes) {
+                if (type.getDirectDescendantClasses().isEmpty()) {
+                    classesToNotAddTypeProperty.add(type.getJavaClass());
+                }
+            }
+        }
+        if (configuration.isAlwaysIncludeTypeProperty() && configuration.isStandardsCompliantExpressions()) {
+            classesToNotAddTypeProperty.add(RulesSection.class);
+        }
+    }
+
+    @Override
+    public boolean useForType(JavaType t) {
+        return OpenEHRBase.class.isAssignableFrom(t.getRawClass())
+                && !classesToNotAddTypeProperty.contains(t.getRawClass());
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/JacksonUtil3.java b/archie-utils/src/main/java/com/nedap/archie/json3/JacksonUtil3.java
new file mode 100644
index 000000000..98e47bddc
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/JacksonUtil3.java
@@ -0,0 +1,139 @@
+package com.nedap.archie.json3;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import tools.jackson.databind.*;
+import tools.jackson.databind.cfg.DateTimeFeature;
+import tools.jackson.databind.cfg.MapperBuilder;
+import tools.jackson.databind.deser.DeserializationProblemHandler;
+import tools.jackson.databind.json.JsonMapper;
+import tools.jackson.databind.jsontype.TypeResolverBuilder;
+import tools.jackson.databind.module.SimpleModule;
+import com.nedap.archie.aom.*;
+import com.nedap.archie.aom.primitives.CTemporal;
+import com.nedap.archie.json.ArchieJacksonConfiguration;
+import com.nedap.archie.json.DontSerializePathMixin;
+import com.nedap.archie.json.ExcludeEmptyCollectionsFilter;
+import com.nedap.archie.json.FixArchetypeIDMixin;
+import com.nedap.archie.json.IsPrefixArchetypeMixin;
+import com.nedap.archie.json.IsPrefixArchetypeSlotMixin;
+import com.nedap.archie.json.IsPrefixAuthoredResourceMixin;
+import com.nedap.archie.json.IsPrefixCObjectMixin;
+import com.nedap.archie.json.IsPrefixCPrimitiveObjectMixin;
+import com.nedap.archie.json.OperatorLegacyFormatMixin;
+import com.nedap.archie.json.PatternConstraintCTemporalMixin;
+import com.nedap.archie.json.RulesSectionMixin;
+import com.nedap.archie.rm.archetyped.Pathable;
+import com.nedap.archie.rm.support.identification.ArchetypeID;
+import com.nedap.archie.rules.Operator;
+import com.nedap.archie.rules.OperatorKind;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Jackson 3 port of {@link com.nedap.archie.json.JacksonUtil}.
+ * <p>
+ * In Jackson 3, ObjectMapper is immutable; all configuration is done via {@link MapperBuilder}.
+ * Use {@link #configureBuilder(MapperBuilder, ArchieJacksonConfiguration)} to configure a builder,
+ * or {@link #getObjectMapper(ArchieJacksonConfiguration)} to get a pre-built mapper.
+ */
+public class JacksonUtil3 {
+
+    private static final ConcurrentHashMap<ArchieJacksonConfiguration, ObjectMapper> objectMapperByConfiguration = new ConcurrentHashMap<>();
+
+    public static ObjectMapper getObjectMapper() {
+        return getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
+    }
+
+    public static ObjectMapper getObjectMapper(ArchieJacksonConfiguration configuration) {
+        ObjectMapper objectMapper = objectMapperByConfiguration.get(configuration);
+        if (objectMapper == null) {
+            JsonMapper.Builder builder = JsonMapper.builder();
+            configureBuilder(builder, configuration);
+            objectMapper = builder.build();
+            objectMapperByConfiguration.put(configuration, objectMapper);
+        }
+        return objectMapper;
+    }
+
+    public static void configureBuilder(MapperBuilder<?, ?> builder) {
+        configureBuilder(builder, ArchieJacksonConfiguration.createStandardsCompliant());
+    }
+
+    public static void configureBuilder(MapperBuilder<?, ?> builder, ArchieJacksonConfiguration configuration) {
+        builder.enable(SerializationFeature.INDENT_OUTPUT);
+        builder.enable(SerializationFeature.FLUSH_AFTER_WRITE_VALUE);
+        builder.disable(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS);
+        builder.disable(DateTimeFeature.WRITE_DURATIONS_AS_TIMESTAMPS);
+        builder.propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
+        builder.enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
+        builder.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
+        builder.enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS);
+
+        if (!configuration.isSerializeEmptyCollections()) {
+            builder.changeDefaultPropertyInclusion(v -> JsonInclude.Value.construct(
+                    JsonInclude.Include.CUSTOM,
+                    JsonInclude.Include.USE_DEFAULTS,
+                    ExcludeEmptyCollectionsFilter.class,
+                    null));
+        } else {
+            builder.changeDefaultPropertyInclusion(v -> v.withValueInclusion(JsonInclude.Include.NON_NULL));
+        }
+
+        if (configuration.isFailOnUnknownProperties()) {
+            builder.enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+        } else {
+            builder.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+        }
+
+        // JSR-310 support is built into Jackson 3's jackson-databind; no separate module needed
+        builder.addModule(new ArchieDurationModule());
+
+        SimpleModule module = new SimpleModule("archie-module");
+        if (!configuration.isAddExtraFieldsInArchetypeId()) {
+            module.setMixInAnnotation(ArchetypeID.class, FixArchetypeIDMixin.class);
+        }
+        if (!configuration.isAddPathProperty()) {
+            module.setMixInAnnotation(Pathable.class, DontSerializePathMixin.class);
+        }
+        if (configuration.isArchetypeBooleanIsPrefix()) {
+            module.setMixInAnnotation(Archetype.class, IsPrefixArchetypeMixin.class);
+            module.setMixInAnnotation(ArchetypeSlot.class, IsPrefixArchetypeSlotMixin.class);
+            module.setMixInAnnotation(AuthoredResource.class, IsPrefixAuthoredResourceMixin.class);
+            module.setMixInAnnotation(CObject.class, IsPrefixCObjectMixin.class);
+            module.setMixInAnnotation(CPrimitiveObject.class, IsPrefixCPrimitiveObjectMixin.class);
+        }
+        if (configuration.isAddPatternConstraintTypo()) {
+            module.setMixInAnnotation(CTemporal.class, PatternConstraintCTemporalMixin.class);
+        }
+        if (configuration.isStandardsCompliantExpressions()) {
+            module.setMixInAnnotation(RulesSection.class, RulesSectionMixin.class);
+        } else {
+            module.addSerializer(OperatorKind.class, new OldOperatorKindSerializer());
+            module.setMixInAnnotation(Operator.class, OperatorLegacyFormatMixin.class);
+        }
+        module.addDeserializer(RulesSection.class, new RulesSectionDeserializer());
+
+        builder.addModule(module);
+        builder.enable(MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL);
+
+        TypeResolverBuilder<?> typeResolverBuilder = new ArchieTypeResolverBuilder3(configuration)
+                .init(JsonTypeInfo.Value.construct(JsonTypeInfo.Id.NAME, JsonTypeInfo.As.PROPERTY,
+                        configuration.getTypePropertyName(), null, true, null),
+                        new OpenEHRTypeNaming3(configuration.isStandardsCompliantExpressions()));
+
+        builder.addHandler(new DeserializationProblemHandler() {
+            @Override
+            public boolean handleUnknownProperty(DeserializationContext ctxt, tools.jackson.core.JsonParser p,
+                                                 ValueDeserializer<?> deserializer, Object beanOrClass,
+                                                 String propertyName) {
+                if (propertyName.equalsIgnoreCase(configuration.getTypePropertyName())) {
+                    return true;
+                }
+                return super.handleUnknownProperty(ctxt, p, deserializer, beanOrClass, propertyName);
+            }
+        });
+
+        builder.setDefaultTyping(typeResolverBuilder);
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/OldOperatorKindSerializer.java b/archie-utils/src/main/java/com/nedap/archie/json3/OldOperatorKindSerializer.java
new file mode 100644
index 000000000..d4360cbc6
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/OldOperatorKindSerializer.java
@@ -0,0 +1,19 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.rules.OperatorKind;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+public class OldOperatorKindSerializer extends ValueSerializer<OperatorKind> {
+
+    @Override
+    public void serialize(OperatorKind value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        if (value == null) {
+            gen.writeNull();
+        } else {
+            gen.writeString(value.name());
+        }
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/OpenEHRTypeNaming3.java b/archie-utils/src/main/java/com/nedap/archie/json3/OpenEHRTypeNaming3.java
new file mode 100644
index 000000000..d8810b921
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/OpenEHRTypeNaming3.java
@@ -0,0 +1,86 @@
+package com.nedap.archie.json3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import tools.jackson.databind.DatabindContext;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.jsontype.TypeIdResolver;
+import com.nedap.archie.base.OpenEHRBase;
+import com.nedap.archie.rminfo.ArchieAOMInfoLookup;
+import com.nedap.archie.rminfo.ArchieRMInfoLookup;
+import com.nedap.archie.rminfo.ModelInfoLookup;
+import com.nedap.archie.rminfo.RMTypeInfo;
+
+/**
+ * Jackson 3 port of {@link com.nedap.archie.json.OpenEHRTypeNaming}.
+ * Handles naming of Archie RM and AOM objects for use in Jackson 3.
+ */
+public class OpenEHRTypeNaming3 implements TypeIdResolver {
+
+    private JavaType _baseType;
+    private final ModelInfoLookup rmInfoLookup = ArchieRMInfoLookup.getInstance();
+    private final ModelInfoLookup aomInfoLookup;
+
+    protected OpenEHRTypeNaming3(boolean standardsCompliantExpressionClassNames) {
+        aomInfoLookup = ArchieAOMInfoLookup.getInstance(standardsCompliantExpressionClassNames);
+    }
+
+    @Override
+    public void init(JavaType baseType) {
+        _baseType = baseType;
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() {
+        return JsonTypeInfo.Id.NAME;
+    }
+
+    @Override
+    public String idFromValue(DatabindContext context, Object value) {
+        RMTypeInfo typeInfo = rmInfoLookup.getTypeInfo(value.getClass());
+        if (typeInfo == null) {
+            typeInfo = aomInfoLookup.getTypeInfo(value.getClass());
+        }
+        if (typeInfo != null) {
+            return typeInfo.getRmName();
+        } else {
+            return rmInfoLookup.getNamingStrategy().getTypeName(value.getClass());
+        }
+    }
+
+    @Override
+    public String idFromValueAndType(DatabindContext context, Object value, Class<?> suggestedType) {
+        return idFromValue(context, value);
+    }
+
+    @Override
+    public String idFromBaseType(DatabindContext context) {
+        if (_baseType != null) {
+            return idFromValue(context, _baseType.getRawClass());
+        }
+        return "";
+    }
+
+    @Override
+    public JavaType typeFromId(DatabindContext context, String id) {
+        Class<?> result = rmInfoLookup.getClass(id);
+        if (result == null) {
+            result = aomInfoLookup.getClass(id);
+        }
+        JavaType baseType = _baseType != null ? _baseType : context.getTypeFactory().constructType(OpenEHRBase.class);
+        if (result != null) {
+            return context.getTypeFactory().constructSpecializedType(baseType, result);
+        }
+        // Try to fall back to class name resolution
+        try {
+            Class<?> cls = Thread.currentThread().getContextClassLoader().loadClass(id);
+            return context.getTypeFactory().constructSpecializedType(baseType, cls);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("No class found for OpenEHR type id: " + id, e);
+        }
+    }
+
+    @Override
+    public String getDescForKnownTypeIds() {
+        return null;
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionDeserializer.java b/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionDeserializer.java
new file mode 100644
index 000000000..b9a07e322
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionDeserializer.java
@@ -0,0 +1,61 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.aom.RulesSection;
+import com.nedap.archie.rules.RuleStatement;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonParser;
+import tools.jackson.core.JsonToken;
+import tools.jackson.databind.DeserializationContext;
+import tools.jackson.databind.ValueDeserializer;
+import tools.jackson.databind.exc.InvalidFormatException;
+
+import java.util.List;
+
+public class RulesSectionDeserializer extends ValueDeserializer<RulesSection> {
+
+    @Override
+    public RulesSection deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+        if (p.isExpectedStartArrayToken()) {
+            List<RuleStatement> list = ctxt.readValue(p, ctxt.getTypeFactory().constructCollectionType(List.class, RuleStatement.class));
+            if (list == null) {
+                return null;
+            }
+            RulesSection section = new RulesSection();
+            section.setRules(list);
+            return section;
+        } else if (p.currentToken() == JsonToken.START_OBJECT || p.currentToken() == JsonToken.PROPERTY_NAME) {
+            CustomRulesSectionJ3 parsed = ctxt.readValue(p, CustomRulesSectionJ3.class);
+            if (parsed == null) {
+                return null;
+            }
+            RulesSection result = new RulesSection();
+            result.setRules(parsed.getRules());
+            result.setContent(parsed.getContent());
+            return result;
+        } else if (p.currentToken() == JsonToken.VALUE_NULL) {
+            return null;
+        }
+        throw new InvalidFormatException(p, "Expected an array of Rules Statements, a Rules section or null - got something else instead", null, RulesSection.class);
+    }
+}
+
+class CustomRulesSectionJ3 {
+    String content;
+    List<RuleStatement> rules;
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public List<RuleStatement> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<RuleStatement> rules) {
+        this.rules = rules;
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionToListConverter.java b/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionToListConverter.java
new file mode 100644
index 000000000..ddacc5cf9
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/json3/RulesSectionToListConverter.java
@@ -0,0 +1,30 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.aom.RulesSection;
+import com.nedap.archie.rules.RuleStatement;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.type.TypeFactory;
+import tools.jackson.databind.util.StdConverter;
+
+import java.util.List;
+
+public class RulesSectionToListConverter extends StdConverter<RulesSection, List<RuleStatement>> {
+
+    @Override
+    public List<RuleStatement> convert(RulesSection value) {
+        if (value == null) {
+            return null;
+        }
+        return value.getRules();
+    }
+
+    @Override
+    public JavaType getInputType(TypeFactory typeFactory) {
+        return typeFactory.constructType(RulesSection.class);
+    }
+
+    @Override
+    public JavaType getOutputType(TypeFactory typeFactory) {
+        return typeFactory.constructCollectionLikeType(List.class, RuleStatement.class);
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingClusterMixin.java b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingClusterMixin.java
index b5370630b..eb1ad1257 100644
--- a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingClusterMixin.java
+++ b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingClusterMixin.java
@@ -1,14 +1,12 @@
 package com.nedap.archie.odin;
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.nedap.archie.rm.datastructures.Item;
 
 import java.util.List;
 
 public interface OdinParsingClusterMixin {
 
-    @JsonDeserialize(converter = ItemMapToListConverter.class)
+    @com.fasterxml.jackson.databind.annotation.JsonDeserialize(converter = ItemMapToListConverter.class)
+    @tools.jackson.databind.annotation.JsonDeserialize(converter = com.nedap.archie.odin3.ItemMapToListConverter.class)
     void setItems(List<Item> child);
-
-
 }
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingDvTextMixin.java b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingDvTextMixin.java
index 58b6d738a..4c1b5cb3c 100644
--- a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingDvTextMixin.java
+++ b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingDvTextMixin.java
@@ -1,12 +1,12 @@
 package com.nedap.archie.odin;
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.nedap.archie.rm.datavalues.TermMapping;
 
 import java.util.List;
 
 public interface OdinParsingDvTextMixin {
 
-    @JsonDeserialize(converter=TermMappingMapToListConverter.class)
+    @com.fasterxml.jackson.databind.annotation.JsonDeserialize(converter = TermMappingMapToListConverter.class)
+    @tools.jackson.databind.annotation.JsonDeserialize(converter = com.nedap.archie.odin3.TermMappingMapToListConverter.class)
     void setMappings(List<TermMapping> mappings);
 }
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingItemTreeMixin.java b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingItemTreeMixin.java
index 46b28bbbd..4c142842e 100644
--- a/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingItemTreeMixin.java
+++ b/archie-utils/src/main/java/com/nedap/archie/odin/OdinParsingItemTreeMixin.java
@@ -1,12 +1,12 @@
 package com.nedap.archie.odin;
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.nedap.archie.rm.datastructures.Item;
 
 import java.util.List;
 
 public interface OdinParsingItemTreeMixin {
 
-    @JsonDeserialize(converter = ItemMapToListConverter.class)
+    @com.fasterxml.jackson.databind.annotation.JsonDeserialize(converter = ItemMapToListConverter.class)
+    @tools.jackson.databind.annotation.JsonDeserialize(converter = com.nedap.archie.odin3.ItemMapToListConverter.class)
     void setItems(List<Item> items);
 }
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin3/BaseMapToListConverter.java b/archie-utils/src/main/java/com/nedap/archie/odin3/BaseMapToListConverter.java
new file mode 100644
index 000000000..40f34cfb1
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/odin3/BaseMapToListConverter.java
@@ -0,0 +1,18 @@
+package com.nedap.archie.odin3;
+
+import tools.jackson.databind.util.StdConverter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public abstract class BaseMapToListConverter<T> extends StdConverter<Map<?, T>, List<T>> {
+
+    @Override
+    public List<T> convert(Map<?, T> map) {
+        if (map == null) {
+            return null;
+        }
+        return new ArrayList<>(map.values());
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin3/ItemMapToListConverter.java b/archie-utils/src/main/java/com/nedap/archie/odin3/ItemMapToListConverter.java
new file mode 100644
index 000000000..40824bc7e
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/odin3/ItemMapToListConverter.java
@@ -0,0 +1,22 @@
+package com.nedap.archie.odin3;
+
+import com.nedap.archie.rm.datastructures.Item;
+import tools.jackson.core.type.TypeReference;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.type.TypeFactory;
+
+import java.util.List;
+import java.util.Map;
+
+public class ItemMapToListConverter extends BaseMapToListConverter<Item> {
+
+    @Override
+    public JavaType getInputType(TypeFactory typeFactory) {
+        return typeFactory.constructType(new TypeReference<Map<?, Item>>() {});
+    }
+
+    @Override
+    public JavaType getOutputType(TypeFactory typeFactory) {
+        return typeFactory.constructType(new TypeReference<List<Item>>() {});
+    }
+}
diff --git a/archie-utils/src/main/java/com/nedap/archie/odin3/TermMappingMapToListConverter.java b/archie-utils/src/main/java/com/nedap/archie/odin3/TermMappingMapToListConverter.java
new file mode 100644
index 000000000..17f558a39
--- /dev/null
+++ b/archie-utils/src/main/java/com/nedap/archie/odin3/TermMappingMapToListConverter.java
@@ -0,0 +1,22 @@
+package com.nedap.archie.odin3;
+
+import com.nedap.archie.rm.datavalues.TermMapping;
+import tools.jackson.core.type.TypeReference;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.type.TypeFactory;
+
+import java.util.List;
+import java.util.Map;
+
+public class TermMappingMapToListConverter extends BaseMapToListConverter<TermMapping> {
+
+    @Override
+    public JavaType getInputType(TypeFactory typeFactory) {
+        return typeFactory.constructType(new TypeReference<Map<?, TermMapping>>() {});
+    }
+
+    @Override
+    public JavaType getOutputType(TypeFactory typeFactory) {
+        return typeFactory.constructType(new TypeReference<List<TermMapping>>() {});
+    }
+}
diff --git a/archie-utils/src/test/java/com/nedap/archie/json3/OpenEHRTypeNaming3Test.java b/archie-utils/src/test/java/com/nedap/archie/json3/OpenEHRTypeNaming3Test.java
new file mode 100644
index 000000000..fbe7784da
--- /dev/null
+++ b/archie-utils/src/test/java/com/nedap/archie/json3/OpenEHRTypeNaming3Test.java
@@ -0,0 +1,83 @@
+package com.nedap.archie.json3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.nedap.archie.json.JacksonUtil;
+import com.nedap.archie.rm.composition.Composition;
+import com.nedap.archie.rm.datavalues.DvText;
+import org.junit.jupiter.api.Test;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.json.JsonMapper;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Direct unit tests for OpenEHRTypeNaming3 — covers the methods Jackson 3 doesn't
+ * call automatically during normal serialization (init, getMechanism, idFromBaseType, etc.).
+ */
+public class OpenEHRTypeNaming3Test {
+
+    private OpenEHRTypeNaming3 resolver() {
+        return new OpenEHRTypeNaming3(false);
+    }
+
+    @Test
+    public void getMechanism_returnsName() {
+        assertEquals(JsonTypeInfo.Id.NAME, resolver().getMechanism());
+    }
+
+    @Test
+    public void getDescForKnownTypeIds_returnsNull() {
+        assertNull(resolver().getDescForKnownTypeIds());
+    }
+
+    @Test
+    public void init_storesBaseType() {
+        OpenEHRTypeNaming3 r = resolver();
+        JavaType jt = JsonMapper.builder().build().getTypeFactory().constructType(DvText.class);
+        r.init(jt);
+    }
+
+    @Test
+    public void idFromValueAndType_delegatesToIdFromValue() {
+        OpenEHRTypeNaming3 r = resolver();
+        DvText value = new DvText("hello");
+        String fromValue = r.idFromValue(null, value);
+        String fromValueAndType = r.idFromValueAndType(null, value, DvText.class);
+        assertEquals(fromValue, fromValueAndType);
+    }
+
+    @Test
+    public void idFromBaseType_withoutInit_returnsEmpty() {
+        OpenEHRTypeNaming3 r = resolver();
+        assertEquals("", r.idFromBaseType(null));
+    }
+
+    @Test
+    public void idFromBaseType_withInit_returnsTypeName() {
+        OpenEHRTypeNaming3 r = resolver();
+        JavaType jt = JsonMapper.builder().build().getTypeFactory().constructType(Composition.class);
+        r.init(jt);
+        String result = r.idFromBaseType(null);
+        assertNotNull(result);
+    }
+
+    @Test
+    public void idFromValue_unknownClass_fallsBackToNamingStrategy() {
+        OpenEHRTypeNaming3 r = resolver();
+        // Use a class not registered in either RM or AOM lookup
+        String result = r.idFromValue(null, new Object());
+        assertNotNull(result);
+    }
+
+    @Test
+    public void jackson2AndJackson3ProduceSameOutput() throws Exception {
+        DvText dvText = new DvText("hello world");
+        String j2 = JacksonUtil.getObjectMapper().writeValueAsString(dvText);
+        String j3 = JacksonUtil3.getObjectMapper().writeValueAsString(dvText);
+        // Field ordering may differ between J2/J3; compare semantic content
+        assertEquals(
+            JacksonUtil.getObjectMapper().readTree(j2),
+            JacksonUtil.getObjectMapper().readTree(j3)
+        );
+    }
+}
diff --git a/bmm/src/main/java/org/openehr/bmm/v2/persistence/BmmTypeNames.java b/bmm/src/main/java/org/openehr/bmm/v2/persistence/BmmTypeNames.java
new file mode 100644
index 000000000..395c3b17a
--- /dev/null
+++ b/bmm/src/main/java/org/openehr/bmm/v2/persistence/BmmTypeNames.java
@@ -0,0 +1,35 @@
+package org.openehr.bmm.v2.persistence;
+
+import com.google.common.collect.ImmutableBiMap;
+import com.nedap.archie.base.Interval;
+
+/**
+ * Shared type name mappings used by both Jackson 2 and Jackson 3 type resolvers.
+ */
+public class BmmTypeNames {
+
+    public static final ImmutableBiMap<String, Class<?>> classNaming = ImmutableBiMap.<String, Class<?>>builder()
+            .put("BMM_INCLUDE_SPEC", BmmIncludeSpec.class)
+            .put("P_BMM_CLASS", PBmmClass.class)
+            .put("P_BMM_CONTAINER_PROPERTY", PBmmContainerProperty.class)
+            .put("P_BMM_ENUMERATION", PBmmEnumeration.class)
+            .put("P_BMM_ENUMERATION_STRING", PBmmEnumerationString.class)
+            .put("P_BMM_ENUMERATION_INTEGER", PBmmEnumerationInteger.class)
+            .put("P_BMM_GENERIC_PARAMETER", PBmmGenericParameter.class)
+            .put("P_BMM_GENERIC_PROPERTY", PBmmGenericProperty.class)
+            .put("P_BMM_GENERIC_TYPE", PBmmGenericType.class)
+            .put("P_BMM_OPEN_TYPE", PBmmOpenType.class)
+            .put("P_BMM_CONTAINER_TYPE", PBmmContainerType.class)
+            .put("P_BMM_PACKAGE", PBmmPackage.class)
+            .put("P_BMM_PROPERTY", PBmmProperty.class)
+            .put("P_BMM_SCHEMA", PBmmSchema.class)
+            .put("P_BMM_SIMPLE_TYPE", PBmmSimpleType.class)
+            .put("P_BMM_SINGLE_PROPERTY", PBmmSingleProperty.class)
+            .put("P_BMM_SINGLE_PROPERTY_OPEN", PBmmSinglePropertyOpen.class)
+            .put("P_BMM_UNITARY_TYPE", PBmmUnitaryType.class)
+            .put("P_BMM_TYPE", PBmmType.class)
+            .put("INTERVAL", Interval.class)
+            .build();
+
+    public static final ImmutableBiMap<Class<?>, String> inverseClassNaming = classNaming.inverse();
+}
diff --git a/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson/BmmTypeNaming.java b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson/BmmTypeNaming.java
index 19ebf66f0..da953c57c 100644
--- a/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson/BmmTypeNaming.java
+++ b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson/BmmTypeNaming.java
@@ -6,10 +6,9 @@
 import com.fasterxml.jackson.databind.jsontype.impl.ClassNameIdResolver;
 import com.fasterxml.jackson.databind.type.TypeFactory;
 import com.google.common.collect.ImmutableBiMap;
-import com.nedap.archie.base.Interval;
 import com.nedap.archie.base.OpenEHRBase;
 import org.openehr.bmm.persistence.validation.BmmDefinitions;
-import org.openehr.bmm.v2.persistence.*;
+import org.openehr.bmm.v2.persistence.BmmTypeNames;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -22,29 +21,8 @@
  */
 public class BmmTypeNaming extends ClassNameIdResolver {
 
-    private final static ImmutableBiMap<String, Class<?>> classNaming = ImmutableBiMap.<String, Class<?>>builder().
-        put("BMM_INCLUDE_SPEC", BmmIncludeSpec.class).
-        put("P_BMM_CLASS", PBmmClass.class).
-        put("P_BMM_CONTAINER_PROPERTY", PBmmContainerProperty.class).
-        put("P_BMM_ENUMERATION", PBmmEnumeration.class).
-        put("P_BMM_ENUMERATION_STRING", PBmmEnumerationString.class).
-        put("P_BMM_ENUMERATION_INTEGER", PBmmEnumerationInteger.class).
-        put("P_BMM_GENERIC_PARAMETER", PBmmGenericParameter.class).
-        put("P_BMM_GENERIC_PROPERTY", PBmmGenericProperty.class).
-        put("P_BMM_GENERIC_TYPE", PBmmGenericType.class).
-        put("P_BMM_OPEN_TYPE", PBmmOpenType.class).
-        put("P_BMM_CONTAINER_TYPE", PBmmContainerType.class).
-        put("P_BMM_PACKAGE", PBmmPackage.class).
-        put("P_BMM_PROPERTY", PBmmProperty.class).
-        put("P_BMM_SCHEMA", PBmmSchema.class).
-        put("P_BMM_SIMPLE_TYPE", PBmmSimpleType.class).
-        put("P_BMM_SINGLE_PROPERTY", PBmmSingleProperty.class).
-        put("P_BMM_SINGLE_PROPERTY_OPEN", PBmmSinglePropertyOpen.class).
-        put("P_BMM_UNITARY_TYPE", PBmmUnitaryType.class).
-        put("P_BMM_TYPE", PBmmType.class).
-        put("INTERVAL", Interval.class).build();
-
-    private final static ImmutableBiMap<Class<?>, String>  inverseClassNaming = classNaming.inverse();
+    private final static ImmutableBiMap<String, Class<?>> classNaming = BmmTypeNames.classNaming;
+    private final static ImmutableBiMap<Class<?>, String> inverseClassNaming = BmmTypeNames.inverseClassNaming;
 
     protected BmmTypeNaming() {
         super(TypeFactory.defaultInstance().constructType(OpenEHRBase.class), TypeFactory.defaultInstance());
diff --git a/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmJacksonUtil3.java b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmJacksonUtil3.java
new file mode 100644
index 000000000..7864df729
--- /dev/null
+++ b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmJacksonUtil3.java
@@ -0,0 +1,66 @@
+package org.openehr.bmm.v2.persistence.jackson3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import tools.jackson.core.StreamReadFeature;
+import tools.jackson.databind.*;
+import tools.jackson.databind.deser.DeserializationProblemHandler;
+import tools.jackson.databind.json.JsonMapper;
+import tools.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import tools.jackson.databind.jsontype.impl.DefaultTypeResolverBuilder;
+import com.nedap.archie.base.OpenEHRBase;
+
+/**
+ * Jackson 3 port of {@link org.openehr.bmm.v2.persistence.jackson.BmmJacksonUtil}.
+ */
+public class BmmJacksonUtil3 {
+
+    private volatile static ObjectMapper objectMapper;
+
+    public static ObjectMapper getObjectMapper() {
+        if (objectMapper == null) {
+            objectMapper = createObjectMapper();
+        }
+        return objectMapper;
+    }
+
+    public static ObjectMapper createObjectMapper() {
+        BmmTypeResolverBuilder3 typeResolverBuilder = new BmmTypeResolverBuilder3();
+        typeResolverBuilder.typeIdVisibility(true);
+        typeResolverBuilder.init(
+                JsonTypeInfo.Value.construct(JsonTypeInfo.Id.NAME, JsonTypeInfo.As.PROPERTY,
+                        "_type", null, true, null),
+                new BmmTypeNaming3());
+
+        return JsonMapper.builder()
+                .propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
+                .enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
+                .enable(StreamReadFeature.STRICT_DUPLICATE_DETECTION)
+                .enable(MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL)
+                .disable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY)
+                .addHandler(new DeserializationProblemHandler() {
+                    @Override
+                    public boolean handleUnknownProperty(DeserializationContext ctxt, tools.jackson.core.JsonParser p,
+                                                         ValueDeserializer<?> deserializer, Object beanOrClass,
+                                                         String propertyName) {
+                        if (propertyName.equalsIgnoreCase("_type")) {
+                            return true;
+                        }
+                        return super.handleUnknownProperty(ctxt, p, deserializer, beanOrClass, propertyName);
+                    }
+                })
+                .setDefaultTyping(typeResolverBuilder)
+                .build();
+    }
+
+    static class BmmTypeResolverBuilder3 extends DefaultTypeResolverBuilder {
+        public BmmTypeResolverBuilder3() {
+            super(BasicPolymorphicTypeValidator.builder().allowIfBaseType(OpenEHRBase.class).build(),
+                    DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
+        }
+
+        @Override
+        public boolean useForType(JavaType t) {
+            return OpenEHRBase.class.isAssignableFrom(t.getRawClass()) && super.useForType(t);
+        }
+    }
+}
diff --git a/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3.java b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3.java
new file mode 100644
index 000000000..9af732f93
--- /dev/null
+++ b/bmm/src/main/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3.java
@@ -0,0 +1,77 @@
+package org.openehr.bmm.v2.persistence.jackson3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import tools.jackson.databind.DatabindContext;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.jsontype.TypeIdResolver;
+import com.google.common.collect.ImmutableBiMap;
+import com.nedap.archie.base.OpenEHRBase;
+import org.openehr.bmm.persistence.validation.BmmDefinitions;
+import org.openehr.bmm.v2.persistence.BmmTypeNames;
+
+import java.util.Objects;
+
+/**
+ * Jackson 3 port of {@link org.openehr.bmm.v2.persistence.jackson.BmmTypeNaming}.
+ */
+public class BmmTypeNaming3 implements TypeIdResolver {
+
+    private JavaType _baseType;
+
+    private final static ImmutableBiMap<String, Class<?>> classNaming = BmmTypeNames.classNaming;
+    private final static ImmutableBiMap<Class<?>, String> inverseClassNaming = BmmTypeNames.inverseClassNaming;
+
+    protected BmmTypeNaming3() {
+    }
+
+    @Override
+    public void init(JavaType baseType) {
+        _baseType = baseType;
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() {
+        return JsonTypeInfo.Id.NAME;
+    }
+
+    @Override
+    public String idFromValue(DatabindContext context, Object value) {
+        String result = inverseClassNaming.get(value.getClass());
+        return Objects.requireNonNullElseGet(result, () -> value.getClass().getSimpleName());
+    }
+
+    @Override
+    public String idFromValueAndType(DatabindContext context, Object value, Class<?> suggestedType) {
+        return idFromValue(context, value);
+    }
+
+    @Override
+    public String idFromBaseType(DatabindContext context) {
+        if (_baseType != null) {
+            return idFromValue(context, _baseType.getRawClass());
+        }
+        return "";
+    }
+
+    @Override
+    public JavaType typeFromId(DatabindContext context, String id) {
+        String classKey = BmmDefinitions.typeNameToClassKey(id);
+        Class<?> result = classNaming.get(classKey);
+        JavaType baseType = _baseType != null ? _baseType : context.getTypeFactory().constructType(OpenEHRBase.class);
+        if (result != null) {
+            return context.getTypeFactory().constructSpecializedType(baseType, result);
+        }
+        // Fall back to class name resolution
+        try {
+            Class<?> cls = Thread.currentThread().getContextClassLoader().loadClass(id);
+            return context.getTypeFactory().constructSpecializedType(baseType, cls);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("No class found for BMM type id: " + id, e);
+        }
+    }
+
+    @Override
+    public String getDescForKnownTypeIds() {
+        return null;
+    }
+}
diff --git a/bmm/src/test/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3Test.java b/bmm/src/test/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3Test.java
new file mode 100644
index 000000000..7909c04db
--- /dev/null
+++ b/bmm/src/test/java/org/openehr/bmm/v2/persistence/jackson3/BmmTypeNaming3Test.java
@@ -0,0 +1,71 @@
+package org.openehr.bmm.v2.persistence.jackson3;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.junit.jupiter.api.Test;
+import org.openehr.bmm.v2.persistence.PBmmSchema;
+import org.openehr.bmm.v2.persistence.jackson.BmmJacksonUtil;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.json.JsonMapper;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Direct unit tests for BmmTypeNaming3 — covers methods not reachable from normal
+ * serialization flow (init, getMechanism, idFromBaseType, getDescForKnownTypeIds, etc.).
+ */
+public class BmmTypeNaming3Test {
+
+    private BmmTypeNaming3 resolver() {
+        return new BmmTypeNaming3();
+    }
+
+    @Test
+    public void getMechanism_returnsName() {
+        assertEquals(JsonTypeInfo.Id.NAME, resolver().getMechanism());
+    }
+
+    @Test
+    public void getDescForKnownTypeIds_returnsNull() {
+        assertNull(resolver().getDescForKnownTypeIds());
+    }
+
+    @Test
+    public void init_storesBaseType() {
+        BmmTypeNaming3 r = resolver();
+        JavaType jt = JsonMapper.builder().build().getTypeFactory().constructType(PBmmSchema.class);
+        r.init(jt);
+    }
+
+    @Test
+    public void idFromValueAndType_delegatesToIdFromValue() {
+        BmmTypeNaming3 r = resolver();
+        PBmmSchema schema = new PBmmSchema();
+        String fromValue = r.idFromValue(null, schema);
+        String fromValueAndType = r.idFromValueAndType(null, schema, PBmmSchema.class);
+        assertEquals(fromValue, fromValueAndType);
+    }
+
+    @Test
+    public void idFromBaseType_withoutInit_returnsEmpty() {
+        BmmTypeNaming3 r = resolver();
+        assertEquals("", r.idFromBaseType(null));
+    }
+
+    @Test
+    public void idFromBaseType_withInit_returnsTypeName() {
+        BmmTypeNaming3 r = resolver();
+        JavaType jt = JsonMapper.builder().build().getTypeFactory().constructType(PBmmSchema.class);
+        r.init(jt);
+        String result = r.idFromBaseType(null);
+        assertNotNull(result);
+    }
+
+    @Test
+    public void jackson2AndJackson3ProduceSameOutput() throws Exception {
+        PBmmSchema schema = new PBmmSchema();
+        schema.setBmmVersion("2.3");
+        String j2 = BmmJacksonUtil.getObjectMapper().writeValueAsString(schema);
+        String j3 = BmmJacksonUtil3.getObjectMapper().writeValueAsString(schema);
+        assertEquals(j2, j3);
+    }
+}
diff --git a/bmm/src/test/java/org/openehr/bmm/v2/persistence/odin/BmmOdinParserTest.java b/bmm/src/test/java/org/openehr/bmm/v2/persistence/odin/BmmOdinParserTest.java
index 92542ce0a..0c6cda8ec 100644
--- a/bmm/src/test/java/org/openehr/bmm/v2/persistence/odin/BmmOdinParserTest.java
+++ b/bmm/src/test/java/org/openehr/bmm/v2/persistence/odin/BmmOdinParserTest.java
@@ -1,22 +1,61 @@
 package org.openehr.bmm.v2.persistence.odin;
 
+import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.openehr.bmm.v2.persistence.PBmmSchema;
 import org.openehr.bmm.v2.persistence.jackson.BmmJacksonUtil;
+import org.openehr.bmm.v2.persistence.jackson3.BmmJacksonUtil3;
 
-import java.io.IOException;
 import java.io.InputStream;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class BmmOdinParserTest {
 
-    @Test
-    public void parseTestBmm1() throws IOException {
-        try(InputStream stream = getClass().getResourceAsStream("/testbmm/TestBmm1.bmm")) {//"/testbmm/TestBmm1.bmm")) {
-            PBmmSchema schema = BmmOdinParser.convert(stream);
+    interface JsonMapper {
+        String writeValueAsString(Object value) throws Exception;
+    }
 
-            String s = BmmJacksonUtil.getObjectMapper().writeValueAsString(schema);
+    private static Stream<Arguments> mappers() {
+        return Stream.of(
+                Arguments.of(Named.of("Jackson 2", (JsonMapper) o -> BmmJacksonUtil.getObjectMapper().writeValueAsString(o))),
+                Arguments.of(Named.of("Jackson 3", (JsonMapper) o -> BmmJacksonUtil3.getObjectMapper().writeValueAsString(o)))
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseTestBmm1(JsonMapper mapper) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/testbmm/TestBmm1.bmm")) {
+            PBmmSchema schema = BmmOdinParser.convert(stream);
+            String s = mapper.writeValueAsString(schema);
             System.out.println(s);
+        }
+    }
 
+    @Test
+    public void jackson3OutputMatchesJackson2() throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/testbmm/TestBmm1.bmm")) {
+            PBmmSchema schema = BmmOdinParser.convert(stream);
+            String j2 = BmmJacksonUtil.getObjectMapper().writeValueAsString(schema);
+            String j3 = BmmJacksonUtil3.getObjectMapper().writeValueAsString(schema);
+            assertEquals(j2, j3);
+        }
+    }
+
+    @Test
+    public void jackson3RoundTrip() throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/testbmm/TestBmm1.bmm")) {
+            PBmmSchema original = BmmOdinParser.convert(stream);
+            String json = BmmJacksonUtil3.getObjectMapper().writeValueAsString(original);
+            PBmmSchema roundTripped = BmmJacksonUtil3.getObjectMapper().readValue(json, PBmmSchema.class);
+            // Re-serialize to confirm the round-tripped schema produces the same output
+            String json2 = BmmJacksonUtil3.getObjectMapper().writeValueAsString(roundTripped);
+            assertEquals(json, json2);
         }
     }
 }
diff --git a/build.gradle b/build.gradle
index 9a5e546be..70e679f81 100644
--- a/build.gradle
+++ b/build.gradle
@@ -55,6 +55,7 @@ subprojects {
         api(libs.slf4j.api)
 
         api(libs.bundles.jackson)
+        api(libs.jackson3.databind)
 
         implementation(libs.guava)
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c67e22aeb..93079aa02 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,6 +3,7 @@ antlr = "4.13.2"
 
 jackson = "2.21.3"
 jackson_annotations = "2.22"
+jackson3 = "3.0.0"
 
 slf4j = "1.7.36"
 
@@ -11,7 +12,7 @@ nexus-publish = { id = "io.github.gradle-nexus.publish-plugin", version = "2.0.0
 
 [bundles]
 jackson = ["jackson-annotations", "jackson-databind", "jackson-datatype-jsr310"]
-junit = ["junit5-jupiter", "junit5-jupiter-engine", "junit5-platform-launcher"]
+junit = ["junit5-jupiter", "junit5-jupiter-engine", "junit5-jupiter-params", "junit5-platform-launcher"]
 
 [libraries]
 activation = { module = "javax.activation:activation", version = "1.1.1" }
@@ -31,6 +32,8 @@ jackson-annotations = { module = "com.fasterxml.jackson.core:jackson-annotations
 jackson-databind = { module = "com.fasterxml.jackson.core:jackson-databind", version.ref = "jackson" }
 jackson-datatype-jsr310 = { module = "com.fasterxml.jackson.datatype:jackson-datatype-jsr310", version.ref = "jackson" }
 
+jackson3-databind = { module = "tools.jackson.core:jackson-databind", version.ref = "jackson3" }
+
 jakarta-annotation-api = { module = "jakarta.annotation:jakarta.annotation-api", version = "3.0.0" }
 
 jakarta-json = { module = "org.glassfish:jakarta.json", version = "2.0.1" }
@@ -41,6 +44,7 @@ jaxb-runtime = { module = "org.glassfish.jaxb:jaxb-runtime", version = "4.0.5" }
 
 junit5-jupiter = { module = "org.junit.jupiter:junit-jupiter-api", version = "5.14.3"}
 junit5-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version = "5.14.3"}
+junit5-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version = "5.14.3"}
 junit5-platform-launcher = { module = "org.junit.platform:junit-platform-launcher"}
 
 hamcrest = { module = "org.hamcrest:hamcrest", version = "3.0" }
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/ODINFactory3.java b/odin/src/main/java/org/openehr/odin/jackson3/ODINFactory3.java
new file mode 100644
index 000000000..b97fa3566
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/ODINFactory3.java
@@ -0,0 +1,74 @@
+package org.openehr.odin.jackson3;
+
+import tools.jackson.core.*;
+import tools.jackson.core.io.IOContext;
+import tools.jackson.core.json.JsonFactory;
+
+import java.io.OutputStream;
+import java.io.Writer;
+
+public class ODINFactory3 extends JsonFactory {
+    private static final long serialVersionUID = 1L;
+
+    public final static String FORMAT_NAME_ODIN = "ODIN";
+
+    protected final static int DEFAULT_ODIN_GENERATOR_FEATURE_FLAGS = ODINGenerator3.Feature.collectDefaults();
+
+    protected int _odinGeneratorFeatures = DEFAULT_ODIN_GENERATOR_FEATURE_FLAGS;
+
+    public ODINFactory3() {
+        super();
+        _odinGeneratorFeatures = DEFAULT_ODIN_GENERATOR_FEATURE_FLAGS;
+    }
+
+    public ODINFactory3(ODINFactory3 src) {
+        super(src);
+        _odinGeneratorFeatures = src._odinGeneratorFeatures;
+    }
+
+    @Override
+    public ODINFactory3 copy() {
+        return new ODINFactory3(this);
+    }
+
+    @Override
+    public String getFormatName() {
+        return FORMAT_NAME_ODIN;
+    }
+
+    @Override
+    public boolean canUseCharArrays() {
+        return false;
+    }
+
+    public final ODINFactory3 configure(ODINGenerator3.Feature f, boolean state) {
+        if (state) enable(f); else disable(f);
+        return this;
+    }
+
+    public ODINFactory3 enable(ODINGenerator3.Feature f) {
+        _odinGeneratorFeatures |= f.getMask();
+        return this;
+    }
+
+    public ODINFactory3 disable(ODINGenerator3.Feature f) {
+        _odinGeneratorFeatures &= ~f.getMask();
+        return this;
+    }
+
+    public final boolean isEnabled(ODINGenerator3.Feature f) {
+        return (_odinGeneratorFeatures & f.getMask()) != 0;
+    }
+
+    @Override
+    protected ODINGenerator3 _createGenerator(ObjectWriteContext writeCtxt, IOContext ioCtxt, Writer out)
+            throws JacksonException {
+        return new ODINGenerator3(writeCtxt, ioCtxt, _streamWriteFeatures, _odinGeneratorFeatures, out);
+    }
+
+    @Override
+    protected JsonGenerator _createUTF8Generator(ObjectWriteContext writeCtxt, IOContext ioCtxt, OutputStream out)
+            throws JacksonException {
+        throw new UnsupportedOperationException("UTF-8 byte stream generator not supported for ODIN");
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/ODINGenerator3.java b/odin/src/main/java/org/openehr/odin/jackson3/ODINGenerator3.java
new file mode 100644
index 000000000..b07a4741a
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/ODINGenerator3.java
@@ -0,0 +1,581 @@
+package org.openehr.odin.jackson3;
+
+import tools.jackson.core.*;
+import tools.jackson.core.base.GeneratorBase;
+import tools.jackson.core.io.IOContext;
+import tools.jackson.core.json.JsonWriteContext;
+import tools.jackson.core.util.JacksonFeatureSet;
+import com.nedap.archie.serializer.odin.OdinStringBuilder;
+import com.nedap.archie.serializer.odin.StructuredStringWriter;
+import org.openehr.odin.jackson.OdinObjectWriteContext;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.regex.Pattern;
+
+public class ODINGenerator3 extends GeneratorBase {
+    public static final String WRITE_START_OBJECT_TYPE_MSG = "start an object";
+
+    public enum Feature implements FormatFeature {
+        ;
+
+        protected final boolean _defaultState;
+        protected final int _mask;
+
+        public static int collectDefaults() {
+            int flags = 0;
+            for (Feature f : values()) {
+                if (f.enabledByDefault()) {
+                    flags |= f.getMask();
+                }
+            }
+            return flags;
+        }
+
+        Feature(boolean defaultState) {
+            _defaultState = defaultState;
+            _mask = (1 << ordinal());
+        }
+
+        @Override
+        public boolean enabledByDefault() { return _defaultState; }
+        @Override
+        public boolean enabledIn(int flags) { return (flags & _mask) != 0; }
+        @Override
+        public int getMask() { return _mask; }
+    }
+
+    protected final static long MIN_INT_AS_LONG = (long) Integer.MIN_VALUE;
+    protected final static long MAX_INT_AS_LONG = (long) Integer.MAX_VALUE;
+    protected final static Pattern PLAIN_NUMBER_P = Pattern.compile("[0-9]*(\\.[0-9]*)?");
+
+    protected OdinObjectWriteContext typeIdContext;
+    protected int _formatFeatures;
+    protected final Writer _writer;
+
+    // write context and pretty printer (not in GeneratorBase in Jackson 3)
+    protected JsonWriteContext _writeContext;
+    protected PrettyPrinter _prettyPrinter;
+
+    private OdinStringBuilder builder;
+
+    protected String _objectId;
+    protected String _typeId;
+    protected String _typeIdAtRoot;
+
+    public ODINGenerator3(ObjectWriteContext writeCtxt, IOContext ioCtxt, int stdFeatures, int odinFeatures,
+                          Writer out) throws JacksonException {
+        super(writeCtxt, ioCtxt, stdFeatures);
+        _formatFeatures = odinFeatures;
+        _writer = out;
+        _writeContext = JsonWriteContext.createRootContext(null);
+        PrettyPrinter pp = writeCtxt.getPrettyPrinter();
+        _prettyPrinter = (pp != null) ? pp : _constructDefaultPrettyPrinter();
+        builder = new OdinStringBuilder(new StructuredStringWriter(out));
+        typeIdContext = OdinObjectWriteContext.createRootContext();
+    }
+
+    @Override
+    public Version version() {
+        return Version.unknownVersion();
+    }
+
+    @Override
+    public TokenStreamContext streamWriteContext() {
+        return _writeContext;
+    }
+
+    @Override
+    public Object currentValue() {
+        return _writeContext.currentValue();
+    }
+
+    @Override
+    public void assignCurrentValue(Object value) {
+        _writeContext.assignCurrentValue(value);
+    }
+
+    @Override
+    public PrettyPrinter getPrettyPrinter() {
+        return _prettyPrinter;
+    }
+
+    @Override
+    public Object streamWriteOutputTarget() {
+        return _writer;
+    }
+
+    @Override
+    public int streamWriteOutputBuffered() {
+        return -1;
+    }
+
+    public int getFormatFeatures() {
+        return _formatFeatures;
+    }
+
+    @Override
+    public JacksonFeatureSet<StreamWriteCapability> streamWriteCapabilities() {
+        return DEFAULT_WRITE_CAPABILITIES;
+    }
+
+    public ODINGenerator3 enable(Feature f) {
+        _formatFeatures |= f.getMask();
+        return this;
+    }
+
+    public ODINGenerator3 disable(Feature f) {
+        _formatFeatures &= ~f.getMask();
+        return this;
+    }
+
+    public final boolean isEnabled(Feature f) {
+        return (_formatFeatures & f.getMask()) != 0;
+    }
+
+    public ODINGenerator3 configure(Feature f, boolean state) {
+        if (state) enable(f); else disable(f);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writePOJO(Object pojo) throws JacksonException {
+        return this;
+    }
+
+    @Override
+    public final JsonGenerator writeName(String name) throws JacksonException {
+        int status = _writeContext.writeName(name);
+        if (status == JsonWriteContext.STATUS_EXPECT_VALUE) {
+            throw _constructWriteException("Can not write a field name, expecting a value");
+        }
+        if (status == JsonWriteContext.STATUS_OK_AFTER_COMMA) {
+            _prettyPrinter.writeObjectEntrySeparator(this);
+        } else {
+            _prettyPrinter.beforeObjectEntries(this);
+        }
+        builder.append(name);
+        return this;
+    }
+
+    @Override
+    public final JsonGenerator writeName(SerializableString name) throws JacksonException {
+        return writeName(name.getValue());
+    }
+
+    @Override
+    public final JsonGenerator writePropertyId(long id) throws JacksonException {
+        return writeName(Long.toString(id));
+    }
+
+    @Override
+    public final void flush() {
+        try {
+            _writer.flush();
+        } catch (IOException e) {
+            throw _wrapIOFailure(e);
+        }
+    }
+
+    @Override
+    protected void _closeInput() throws IOException {
+        _writer.close();
+    }
+
+    @Override
+    public final JsonGenerator writeStartArray() throws JacksonException {
+        _verifyValueWrite("start an array");
+        _writeContext = _writeContext.createChildArrayContext(null);
+        typeIdContext = typeIdContext.createChild(null);
+        _objectId = null;
+        builder.append("<");
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeStartArray(Object forValue) throws JacksonException {
+        return writeStartArray();
+    }
+
+    @Override
+    public JsonGenerator writeStartArray(Object forValue, int size) throws JacksonException {
+        return writeStartArray();
+    }
+
+    @Override
+    public final JsonGenerator writeEndArray() throws JacksonException {
+        if (!_writeContext.inArray()) {
+            throw _constructWriteException("Current context not Array but " + _writeContext.typeDesc());
+        }
+        _typeId = null;
+        int index = _writeContext.getCurrentIndex();
+        if (index == 0 && !this.typeIdContext.arrayHasObjects()) {
+            builder.append(", ...");
+        }
+        if (typeIdContext.arrayHasObjects()) {
+            _prettyPrinter.writeEndArray(this, _writeContext.getEntryCount());
+        } else {
+            builder.append(">");
+        }
+        _writeContext = _writeContext.getParent();
+        typeIdContext = typeIdContext.getParent();
+        return this;
+    }
+
+    @Override
+    public final JsonGenerator writeStartObject() throws JacksonException {
+        _verifyValueWrite(WRITE_START_OBJECT_TYPE_MSG);
+        _objectId = null;
+        typeIdContext.markHasChildObjects(true);
+        typeIdContext = typeIdContext.createChild(_typeId);
+        _typeId = null;
+
+        if (_writeContext.inArray()) {
+            if (_writeContext.getCurrentIndex() == 0) {
+                _prettyPrinter.writeStartArray(this);
+                _prettyPrinter.beforeArrayValues(this);
+            }
+            builder.append("[" + (_writeContext.getCurrentIndex() + 1) + "] = ");
+        }
+
+        if (typeIdContext.hasTypeId()) {
+            builder.append("(").append(typeIdContext.getTypeId().toString()).append(") ");
+            _prettyPrinter.writeStartObject(this);
+        } else if (!_writeContext.inRoot()) {
+            _prettyPrinter.writeStartObject(this);
+        }
+
+        _writeContext = _writeContext.createChildObjectContext(null);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeStartObject(Object forValue) throws JacksonException {
+        return writeStartObject();
+    }
+
+    @Override
+    public JsonGenerator writeStartObject(Object forValue, int size) throws JacksonException {
+        return writeStartObject();
+    }
+
+    @Override
+    public final JsonGenerator writeEndObject() throws JacksonException {
+        if (!_writeContext.inObject()) {
+            throw _constructWriteException("Current context not Object but " + _writeContext.typeDesc());
+        }
+        _writeContext = _writeContext.getParent();
+        if (_writeContext.inArray()) {
+            _prettyPrinter.writeEndObject(this, _writeContext.getEntryCount());
+        } else if (_writeContext.inRoot() && _typeIdAtRoot != null) {
+            _prettyPrinter.writeEndObject(this, _writeContext.getEntryCount());
+        } else if (!_writeContext.inRoot()) {
+            _prettyPrinter.writeEndObject(this, _writeContext.getEntryCount());
+        }
+        _typeId = null;
+        typeIdContext = typeIdContext.getParent();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeString(String text) throws JacksonException {
+        if (text == null) {
+            return writeNull();
+        }
+        _verifyValueWrite("write String value");
+        writeFieldStart();
+        builder.text(text);
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeString(char[] text, int offset, int len) throws JacksonException {
+        return writeString(new String(text, offset, len));
+    }
+
+    @Override
+    public JsonGenerator writeString(Reader reader, int len) throws JacksonException {
+        _reportUnsupportedOperation();
+        return this;
+    }
+
+    @Override
+    public final JsonGenerator writeString(SerializableString sstr) throws JacksonException {
+        return writeString(sstr.toString());
+    }
+
+    @Override
+    public JsonGenerator writeRawUTF8String(byte[] text, int offset, int len) throws JacksonException {
+        _reportUnsupportedOperation();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeUTF8String(byte[] text, int offset, int len) throws JacksonException {
+        return writeString(new String(text, offset, len, StandardCharsets.UTF_8));
+    }
+
+    @Override
+    public JsonGenerator writeRaw(String text) throws JacksonException {
+        builder.append(text);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRaw(String text, int offset, int len) throws JacksonException {
+        builder.append(new String(text.getBytes(), offset, len));
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRaw(char[] text, int offset, int len) throws JacksonException {
+        builder.append(new String(text, offset, len));
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRaw(char c) throws JacksonException {
+        builder.append(c);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRawValue(String text) throws JacksonException {
+        _verifyValueWrite("write raw value");
+        writeFieldStart();
+        builder.append(text);
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRawValue(String text, int offset, int len) throws JacksonException {
+        _verifyValueWrite("write raw value");
+        writeRaw(text, offset, len);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeRawValue(char[] text, int offset, int len) throws JacksonException {
+        _verifyValueWrite("write raw value");
+        writeRaw(text, offset, len);
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws JacksonException {
+        if (data == null) {
+            return writeNull();
+        }
+        _verifyValueWrite("write Binary value");
+        if (offset > 0 || (offset + len) != data.length) {
+            data = Arrays.copyOfRange(data, offset, offset + len);
+        }
+        _writeScalarBinary(b64variant, data);
+        return this;
+    }
+
+    @Override
+    public int writeBinary(Base64Variant bv, InputStream data, int dataLength) throws JacksonException {
+        _reportUnsupportedOperation();
+        return -1;
+    }
+
+    @Override
+    public JsonGenerator writeBoolean(boolean state) throws JacksonException {
+        _verifyValueWrite("write boolean value");
+        writeFieldStart();
+        builder.append(state ? "True" : "False");
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(short v) throws JacksonException {
+        return writeNumber((int) v);
+    }
+
+    @Override
+    public JsonGenerator writeNumber(int i) throws JacksonException {
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.append(Integer.toString(i));
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(long l) throws JacksonException {
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.append(Long.toString(l));
+        writeFieldEnd();
+        return this;
+    }
+
+    private void writeFieldStart() {
+        if (!_writeContext.inArray()) {
+            builder.append("<");
+        }
+    }
+
+    private void writeFieldEnd() {
+        if (!_writeContext.inArray()) {
+            builder.append(">");
+        }
+    }
+
+    @Override
+    public JsonGenerator writeNumber(BigInteger v) throws JacksonException {
+        if (v == null) {
+            return writeNull();
+        }
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.append(v.toString());
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(double d) throws JacksonException {
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.append(Double.toString(d));
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(float f) throws JacksonException {
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.append(Float.toString(f));
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(BigDecimal dec) throws JacksonException {
+        if (dec == null) {
+            return writeNull();
+        }
+        _verifyValueWrite("write number");
+        String str = isEnabled(StreamWriteFeature.WRITE_BIGDECIMAL_AS_PLAIN)
+                ? dec.toPlainString() : dec.toString();
+        writeFieldStart();
+        builder.append(str);
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNumber(String encodedValue) throws JacksonException {
+        if (encodedValue == null) {
+            return writeNull();
+        }
+        _verifyValueWrite("write number");
+        writeFieldStart();
+        builder.text(encodedValue);
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeNull() throws JacksonException {
+        _verifyValueWrite("write null value");
+        writeFieldStart();
+        writeFieldEnd();
+        return this;
+    }
+
+    @Override
+    public boolean canWriteObjectId() {
+        return false;
+    }
+
+    @Override
+    public boolean canWriteTypeId() {
+        return true;
+    }
+
+    @Override
+    public JsonGenerator writeTypeId(Object id) throws JacksonException {
+        _typeId = String.valueOf(id);
+        if (_writeContext.inRoot()) {
+            _typeIdAtRoot = _typeId;
+        }
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeObjectRef(Object id) throws JacksonException {
+        _verifyValueWrite("write Object reference");
+        return this;
+    }
+
+    @Override
+    public JsonGenerator writeObjectId(Object id) throws JacksonException {
+        _objectId = String.valueOf(id);
+        return this;
+    }
+
+    @Override
+    protected final void _verifyValueWrite(String typeMsg) throws JacksonException {
+        int status = _writeContext.writeValue();
+        switch (status) {
+            case JsonWriteContext.STATUS_OK_AFTER_COMMA:
+                if (_writeContext.inArray()) {
+                    if (typeIdContext.arrayHasObjects()) {
+                        _prettyPrinter.writeArrayValueSeparator(this);
+                    } else {
+                        writeRaw(", ");
+                    }
+                }
+                break;
+            case JsonWriteContext.STATUS_OK_AFTER_COLON:
+                _prettyPrinter.writeObjectNameValueSeparator(this);
+                break;
+            case JsonWriteContext.STATUS_OK_AFTER_SPACE:
+                _prettyPrinter.writeRootValueSeparator(this);
+                break;
+            case JsonWriteContext.STATUS_OK_AS_IS:
+                if (_writeContext.inArray()) {
+                    // do nothing yet; pretty printer called in writeStartObject if needed
+                } else if (_writeContext.inObject()) {
+                    _prettyPrinter.beforeObjectEntries(this);
+                }
+                break;
+            case JsonWriteContext.STATUS_EXPECT_NAME:
+                throw _constructWriteException("Can not " + typeMsg + ", expecting field name");
+            default:
+                _throwInternal();
+                break;
+        }
+    }
+
+    @Override
+    protected PrettyPrinter _constructDefaultPrettyPrinter() {
+        return new ODINPrettyPrinter3();
+    }
+
+    @Override
+    protected void _releaseBuffers() {
+        // nothing special
+    }
+
+    private void _writeScalarBinary(Base64Variant b64variant, byte[] data) throws JacksonException {
+        if (b64variant == Base64Variants.getDefaultVariant()) {
+            b64variant = Base64Variants.MIME;
+        }
+        String encoded = b64variant.encode(data);
+        builder.text(encoded);
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/ODINMapper3.java b/odin/src/main/java/org/openehr/odin/jackson3/ODINMapper3.java
new file mode 100644
index 000000000..d34c4aed7
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/ODINMapper3.java
@@ -0,0 +1,103 @@
+package org.openehr.odin.jackson3;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import org.openehr.odin.jackson3.serializers.*;
+import tools.jackson.databind.DefaultTyping;
+import tools.jackson.databind.MapperFeature;
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.SerializationFeature;
+import tools.jackson.databind.cfg.MapperBuilder;
+import tools.jackson.databind.cfg.MapperBuilderState;
+import tools.jackson.databind.module.SimpleModule;
+import tools.jackson.databind.PropertyNamingStrategies;
+import tools.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import com.nedap.archie.base.Interval;
+import com.nedap.archie.base.terminology.TerminologyCode;
+
+import java.net.URI;
+import java.net.URL;
+
+/**
+ * Jackson 3 port of {@link org.openehr.odin.jackson.ODINMapper}.
+ */
+public class ODINMapper3 extends ObjectMapper {
+
+    protected ODINMapper3(Builder b) {
+        super(b);
+    }
+
+    public static Builder builder() {
+        return new Builder(new ODINFactory3());
+    }
+
+    public static class Builder extends MapperBuilder<ODINMapper3, Builder> {
+
+        public Builder(ODINFactory3 f) {
+            super(f);
+            propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
+            disable(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS);
+            enable(SerializationFeature.INDENT_OUTPUT);
+            disable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
+            defaultPrettyPrinter(new ODINPrettyPrinter3());
+            changeDefaultPropertyInclusion(v -> JsonInclude.Value.construct(JsonInclude.Include.NON_NULL, JsonInclude.Include.ALWAYS));
+            activateDefaultTyping(
+                    BasicPolymorphicTypeValidator.builder().allowIfBaseType(Object.class).build(),
+                    DefaultTyping.JAVA_LANG_OBJECT);
+
+            SimpleModule odinModule = new SimpleModule("odin-module");
+            odinModule.addKeySerializer(String.class, new OdinStringMapKeySerializer());
+            odinModule.addKeySerializer(Integer.class, new OdinIntegerMapKeySerializer());
+            odinModule.addKeySerializer(Long.class, new OdinLongMapKeySerializer());
+            odinModule.addSerializer(Interval.class, new OdinIntervalSerializer());
+            odinModule.addSerializer(URI.class, new OdinURISerializer());
+            odinModule.addSerializer(URL.class, new OdinURLSerializer());
+            odinModule.addSerializer(TerminologyCode.class, new TerminologyCodeSerializer());
+            addModule(odinModule);
+        }
+
+        public Builder(StateImpl state) {
+            super(state);
+        }
+
+        @Override
+        protected MapperBuilderState _saveState() {
+            return new StateImpl(this);
+        }
+
+        @Override
+        public ODINMapper3 build() {
+            return new ODINMapper3(this);
+        }
+
+        protected static class StateImpl extends MapperBuilderState implements java.io.Serializable {
+            private static final long serialVersionUID = 1L;
+
+            public StateImpl(Builder src) {
+                super(src);
+            }
+
+            @Override
+            protected Object readResolve() {
+                return new Builder(this).build();
+            }
+        }
+    }
+
+    public ODINMapper3 configure(ODINGenerator3.Feature f, boolean state) {
+        return state ? enable(f) : disable(f);
+    }
+
+    public ODINMapper3 enable(ODINGenerator3.Feature f) {
+        ((ODINFactory3) tokenStreamFactory()).enable(f);
+        return this;
+    }
+
+    public ODINMapper3 disable(ODINGenerator3.Feature f) {
+        ((ODINFactory3) tokenStreamFactory()).disable(f);
+        return this;
+    }
+
+    public final ODINFactory3 getFactory() {
+        return (ODINFactory3) tokenStreamFactory();
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/ODINPrettyPrinter3.java b/odin/src/main/java/org/openehr/odin/jackson3/ODINPrettyPrinter3.java
new file mode 100644
index 000000000..cbde78d4c
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/ODINPrettyPrinter3.java
@@ -0,0 +1,177 @@
+package org.openehr.odin.jackson3;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.core.SerializableString;
+import tools.jackson.core.io.SerializedString;
+import tools.jackson.core.util.DefaultIndenter;
+import tools.jackson.core.util.DefaultPrettyPrinter.Indenter;
+import tools.jackson.core.util.DefaultPrettyPrinter.NopIndenter;
+import tools.jackson.core.util.Instantiatable;
+import tools.jackson.core.util.Separators;
+import tools.jackson.core.PrettyPrinter;
+
+/**
+ * PrettyPrinter for ODIN with the ability to set an initial indent level.
+ * Jackson 3 port of {@link org.openehr.odin.jackson.ODINPrettyPrinter}.
+ */
+public class ODINPrettyPrinter3
+        implements PrettyPrinter, Instantiatable<ODINPrettyPrinter3>,
+        java.io.Serializable {
+    private static final long serialVersionUID = 1;
+
+    protected Indenter _objectIndenter = new DefaultIndenter("    ", DefaultIndenter.SYS_LF);
+    protected SerializableString _rootSeparator;
+    protected transient int _nesting;
+    protected Separators _separators;
+    protected String _objectNameValueSeparatorWithSpaces;
+    protected String _objectEmptySeparator;
+    protected String _arrayValueSeparator;
+    protected String _arrayEmptySeparator;
+
+    public ODINPrettyPrinter3() {
+        this(0);
+    }
+
+    public ODINPrettyPrinter3(int nesting) {
+        this(Separators.createDefaultInstance()
+                .withObjectNameValueSeparator('=')
+                .withArrayElementSeparator(','), nesting);
+    }
+
+    public ODINPrettyPrinter3(Separators separators, int nesting) {
+        _separators = separators;
+        _rootSeparator = separators.getRootSeparator() == null ? null
+                : new SerializedString(separators.getRootSeparator());
+        _objectNameValueSeparatorWithSpaces = separators.getObjectNameValueSpacing().apply(
+                separators.getObjectNameValueSeparator());
+        _objectEmptySeparator = separators.getObjectEmptySeparator();
+        _arrayValueSeparator = separators.getArrayElementSpacing().apply(separators.getArrayElementSeparator());
+        _arrayEmptySeparator = separators.getArrayEmptySeparator();
+        _nesting = nesting;
+    }
+
+    public ODINPrettyPrinter3(ODINPrettyPrinter3 base) {
+        _rootSeparator = base._rootSeparator;
+        _objectIndenter = base._objectIndenter;
+        _nesting = base._nesting;
+        _separators = base._separators;
+        _objectNameValueSeparatorWithSpaces = base._objectNameValueSeparatorWithSpaces;
+        _objectEmptySeparator = base._objectEmptySeparator;
+        _arrayValueSeparator = base._arrayValueSeparator;
+        _arrayEmptySeparator = base._arrayEmptySeparator;
+    }
+
+    public void indentObjectsWith(Indenter i) {
+        _objectIndenter = (i == null) ? NopIndenter.instance() : i;
+    }
+
+    public ODINPrettyPrinter3 withObjectIndenter(Indenter i) {
+        if (i == null) {
+            i = NopIndenter.instance();
+        }
+        if (_objectIndenter == i) {
+            return this;
+        }
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3(this);
+        pp._objectIndenter = i;
+        return pp;
+    }
+
+    public ODINPrettyPrinter3 withSeparators(Separators separators) {
+        ODINPrettyPrinter3 result = new ODINPrettyPrinter3(this);
+        result._separators = separators;
+        result._rootSeparator = separators.getRootSeparator() == null ? null
+                : new SerializedString(separators.getRootSeparator());
+        result._objectNameValueSeparatorWithSpaces = separators.getObjectNameValueSpacing().apply(
+                separators.getObjectNameValueSeparator());
+        result._objectEmptySeparator = separators.getObjectEmptySeparator();
+        result._arrayValueSeparator = separators.getArrayElementSpacing().apply(separators.getArrayElementSeparator());
+        result._arrayEmptySeparator = separators.getArrayEmptySeparator();
+        return result;
+    }
+
+    @Override
+    public ODINPrettyPrinter3 createInstance() {
+        if (getClass() != ODINPrettyPrinter3.class) {
+            throw new IllegalStateException("Failed `createInstance()`: " + getClass().getName()
+                    + " does not override method; it has to");
+        }
+        return new ODINPrettyPrinter3(this);
+    }
+
+    @Override
+    public void writeRootValueSeparator(JsonGenerator g) throws JacksonException {
+        if (_rootSeparator != null) {
+            g.writeRaw(_rootSeparator);
+        }
+    }
+
+    @Override
+    public void writeStartObject(JsonGenerator g) throws JacksonException {
+        g.writeRaw('<');
+        if (!_objectIndenter.isInline()) {
+            ++_nesting;
+        }
+    }
+
+    @Override
+    public void beforeObjectEntries(JsonGenerator g) throws JacksonException {
+        if (_nesting > 0) {
+            _objectIndenter.writeIndentation(g, _nesting);
+        }
+    }
+
+    @Override
+    public void writeObjectNameValueSeparator(JsonGenerator g) throws JacksonException {
+        g.writeRaw(_objectNameValueSeparatorWithSpaces);
+    }
+
+    @Override
+    public void writeObjectEntrySeparator(JsonGenerator g) throws JacksonException {
+        _objectIndenter.writeIndentation(g, _nesting);
+    }
+
+    @Override
+    public void writeEndObject(JsonGenerator g, int nrOfEntries) throws JacksonException {
+        if (!_objectIndenter.isInline()) {
+            --_nesting;
+        }
+        if (nrOfEntries > 0) {
+            _objectIndenter.writeIndentation(g, _nesting);
+        } else {
+            g.writeRaw(_objectEmptySeparator);
+        }
+        g.writeRaw('>');
+    }
+
+    @Override
+    public void writeStartArray(JsonGenerator g) throws JacksonException {
+        if (!_objectIndenter.isInline()) {
+            ++_nesting;
+        }
+    }
+
+    @Override
+    public void beforeArrayValues(JsonGenerator g) throws JacksonException {
+        _objectIndenter.writeIndentation(g, _nesting);
+    }
+
+    @Override
+    public void writeArrayValueSeparator(JsonGenerator g) throws JacksonException {
+        _objectIndenter.writeIndentation(g, _nesting);
+    }
+
+    @Override
+    public void writeEndArray(JsonGenerator g, int nrOfValues) throws JacksonException {
+        if (!_objectIndenter.isInline()) {
+            --_nesting;
+        }
+        if (nrOfValues > 0) {
+            _objectIndenter.writeIndentation(g, _nesting);
+        } else {
+            g.writeRaw(_arrayEmptySeparator);
+        }
+        g.writeRaw('>');
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntegerMapKeySerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntegerMapKeySerializer.java
new file mode 100644
index 000000000..9b6d17d8a
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntegerMapKeySerializer.java
@@ -0,0 +1,19 @@
+package org.openehr.odin.jackson3.serializers;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+/**
+ * ODIN map keys serialize differently from propery field names.
+ * Jackson has a mechanism that allows you to set a key serializer. So use this class for that, it adds the key in the
+ * ["key_name"] format without affecting object property names
+ */
+public class OdinIntegerMapKeySerializer extends ValueSerializer<Integer> {
+
+    @Override
+    public void serialize(Integer value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeName("[" + value + "]");
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntervalSerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntervalSerializer.java
new file mode 100644
index 000000000..d8c5b3fee
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinIntervalSerializer.java
@@ -0,0 +1,24 @@
+package org.openehr.odin.jackson3.serializers;
+
+import com.nedap.archie.base.Interval;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+import tools.jackson.databind.jsontype.TypeSerializer;
+
+/**
+ * Serializer that serializes Intervals directly to ODIN
+ */
+public class OdinIntervalSerializer extends ValueSerializer<Interval> {
+
+    @Override
+    public void serialize(Interval value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeRaw(value.toString());
+    }
+
+    @Override
+    public void serializeWithType(Interval value, JsonGenerator gen, SerializationContext ctxt, TypeSerializer typeSer) throws JacksonException {
+        gen.writeRawValue(value.toString());
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinLongMapKeySerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinLongMapKeySerializer.java
new file mode 100644
index 000000000..fb12cb64c
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinLongMapKeySerializer.java
@@ -0,0 +1,19 @@
+package org.openehr.odin.jackson3.serializers;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+/**
+ * ODIN map keys serialize differently from propery field names.
+ * Jackson has a mechanism that allows you to set a key serializer. So use this class for that, it adds the key in the
+ * ["key_name"] format without affecting object property names
+ */
+public class OdinLongMapKeySerializer extends ValueSerializer<Long> {
+
+    @Override
+    public void serialize(Long value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeName("[" + value + "]");
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinStringMapKeySerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinStringMapKeySerializer.java
new file mode 100644
index 000000000..5ab3f903f
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinStringMapKeySerializer.java
@@ -0,0 +1,19 @@
+package org.openehr.odin.jackson3.serializers;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+/**
+ * ODIN map keys serialize differently from propery field names.
+ * Jackson has a mechanism that allows you to set a key serializer. So use this class for that, it adds the key in the
+ * ["key_name"] format without affecting object property names
+ */
+public class OdinStringMapKeySerializer extends ValueSerializer<String> {
+
+    @Override
+    public void serialize(String value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeName("[\"" + value + "\"]");
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURISerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURISerializer.java
new file mode 100644
index 000000000..efeee2073
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURISerializer.java
@@ -0,0 +1,16 @@
+package org.openehr.odin.jackson3.serializers;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+import java.net.URI;
+
+public class OdinURISerializer extends ValueSerializer<URI> {
+
+    @Override
+    public void serialize(URI value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeRawValue(value.toString());
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURLSerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURLSerializer.java
new file mode 100644
index 000000000..81fd0ea05
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/OdinURLSerializer.java
@@ -0,0 +1,16 @@
+package org.openehr.odin.jackson3.serializers;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+import java.net.URL;
+
+public class OdinURLSerializer extends ValueSerializer<URL> {
+
+    @Override
+    public void serialize(URL value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeRawValue(value.toString());
+    }
+}
diff --git a/odin/src/main/java/org/openehr/odin/jackson3/serializers/TerminologyCodeSerializer.java b/odin/src/main/java/org/openehr/odin/jackson3/serializers/TerminologyCodeSerializer.java
new file mode 100644
index 000000000..6e27b9528
--- /dev/null
+++ b/odin/src/main/java/org/openehr/odin/jackson3/serializers/TerminologyCodeSerializer.java
@@ -0,0 +1,21 @@
+package org.openehr.odin.jackson3.serializers;
+
+import com.nedap.archie.base.terminology.TerminologyCode;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+import tools.jackson.databind.jsontype.TypeSerializer;
+
+public class TerminologyCodeSerializer extends ValueSerializer<TerminologyCode> {
+
+    @Override
+    public void serialize(TerminologyCode value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeRawValue(value.toString());
+    }
+
+    @Override
+    public void serializeWithType(TerminologyCode value, JsonGenerator gen, SerializationContext ctxt, TypeSerializer typeSer) throws JacksonException {
+        gen.writeRawValue(value.toString());
+    }
+}
diff --git a/odin/src/test/java/org/openehr/odin/jackson/ODINMapper3InfrastructureTest.java b/odin/src/test/java/org/openehr/odin/jackson/ODINMapper3InfrastructureTest.java
new file mode 100644
index 000000000..3240ef699
--- /dev/null
+++ b/odin/src/test/java/org/openehr/odin/jackson/ODINMapper3InfrastructureTest.java
@@ -0,0 +1,565 @@
+package org.openehr.odin.jackson;
+
+import org.junit.jupiter.api.Test;
+import org.openehr.odin.jackson.testclasses.ContainerWithList;
+import org.openehr.odin.jackson.testclasses.TestObject;
+import org.openehr.odin.jackson3.ODINFactory3;
+import org.openehr.odin.jackson3.ODINGenerator3;
+import org.openehr.odin.jackson3.ODINMapper3;
+import org.openehr.odin.jackson3.ODINPrettyPrinter3;
+import tools.jackson.core.Base64Variants;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.core.ObjectWriteContext;
+import tools.jackson.core.StreamWriteFeature;
+import tools.jackson.core.util.DefaultIndenter;
+
+import java.io.StringWriter;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+//This class can be removed after complete jackson 3 switch
+public class ODINMapper3InfrastructureTest {
+
+    // ── ODINFactory3 ──────────────────────────────────────────────────────────
+    @Test
+    public void factory_formatName() {
+        assertEquals("ODIN", new ODINFactory3().getFormatName());
+    }
+
+    @Test
+    public void factory_cannotUseCharArrays() {
+        assertFalse(new ODINFactory3().canUseCharArrays());
+    }
+
+    @Test
+    public void factory_utf8GeneratorThrows() {
+        ODINMapper3 mapper = ODINMapper3.builder().build();
+        assertThrows(UnsupportedOperationException.class,
+                () -> mapper.writeValueAsBytes(new TestObject()));
+    }
+
+    // ── ODINMapper3 ───────────────────────────────────────────────────────────
+    @Test
+    public void mapper_getFactory() {
+        ODINMapper3 mapper = ODINMapper3.builder().build();
+        ODINFactory3 factory = mapper.getFactory();
+        assertNotNull(factory);
+        assertEquals("ODIN", factory.getFormatName());
+    }
+
+    // ── ODINPrettyPrinter3 ────────────────────────────────────────────────────
+    @Test
+    public void prettyPrinter_createInstance() {
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3();
+        assertNotNull(pp.createInstance());
+    }
+
+    @Test
+    public void prettyPrinter_withObjectIndenter() {
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3();
+        assertNotNull(pp.withObjectIndenter(new tools.jackson.core.util.DefaultIndenter()));
+    }
+
+    @Test
+    public void prettyPrinter_withObjectIndenter_null() {
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3();
+        assertNotNull(pp.withObjectIndenter(null));
+    }
+
+    @Test
+    public void prettyPrinter_withSeparators() {
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3();
+        assertNotNull(pp.withSeparators(tools.jackson.core.util.Separators.createDefaultInstance()));
+    }
+
+    @Test
+    public void prettyPrinter_indentObjectsWith_null() {
+        ODINPrettyPrinter3 pp = new ODINPrettyPrinter3();
+        pp.indentObjectsWith(null);
+    }
+
+    // ── Numeric type serialization (double, float, long) ─────────────────────
+    @Test
+    public void serialize_numericTypes_matchesJackson2() throws Exception {
+        TestObject obj = new TestObject();
+        obj.setStringField("test");
+        obj.setIntField(1);
+        obj.setLongField(123456789L);
+        obj.setDoubleField(3.14);
+        obj.setFloatField(1.5f);
+
+        String j2 = new ODINMapper().writeValueAsString(obj);
+        String j3 = ODINMapper3.builder().deactivateDefaultTyping().build().writeValueAsString(obj);
+        assertEquals(j2, j3);
+    }
+
+    // ── Empty nested object (PrettyPrinter writeEndObject with 0 entries) ────
+    @Test
+    public void serialize_emptyObject_doesNotThrow() {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("nested", new LinkedHashMap<>());
+        ODINMapper3.builder().deactivateDefaultTyping().build().writeValueAsString(map);
+    }
+
+    // ── String-keyed map (exercises OdinStringMapKeySerializer) ──────────────
+    @Test
+    public void serialize_stringKeyedMap_matchesJackson2() throws Exception {
+        ContainerWithList container = new ContainerWithList();
+        container.setSomeField("test");
+        TestObject obj = new TestObject();
+        obj.setStringField("val");
+        obj.setIntField(1);
+        container.addListItem(obj);
+
+        String j2 = new ODINMapper().writeValueAsString(container);
+        String j3 = ODINMapper3.builder().deactivateDefaultTyping().build().writeValueAsString(container);
+        assertEquals(j2, j3);
+    }
+
+    // ── ODINFactory3 copy constructor / copy() ────────────────────────────────
+    @Test
+    public void factory_copy() {
+        ODINFactory3 original = new ODINFactory3();
+        ODINFactory3 copy = original.copy();
+        assertNotNull(copy);
+        assertEquals("ODIN", copy.getFormatName());
+    }
+
+    // ── ODINGenerator3 getter methods ─────────────────────────────────────────
+    @Test
+    public void generator_getterMethods() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            assertNotNull(gen.version());
+            assertNotNull(gen.streamWriteContext());
+            assertNotNull(gen.streamWriteCapabilities());
+            assertEquals(sw, gen.streamWriteOutputTarget());
+            assertEquals(-1, gen.streamWriteOutputBuffered());
+            assertFalse(gen.canWriteObjectId());
+            assertTrue(gen.canWriteTypeId());
+            assertNotNull(gen.getPrettyPrinter());
+            // currentValue and assignCurrentValue
+            gen.assignCurrentValue("test");
+            assertNotNull(gen.currentValue());
+            // getFormatFeatures
+            ((org.openehr.odin.jackson3.ODINGenerator3) gen).getFormatFeatures();
+            // writePOJO and writePropertyId
+            gen.writeStartObject();
+            gen.writePropertyId(1L);
+            gen.writeNumber(42);
+            gen.writeEndObject();
+        }
+    }
+
+    // ── ODINGenerator3 special number types ──────────────────────────────────
+    @Test
+    public void generator_specialNumberTypes() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("bi");
+            gen.writeNumber(BigInteger.valueOf(99999L));
+            gen.writeName("bd");
+            gen.writeNumber(new BigDecimal("3.14159"));
+            gen.writeName("str");
+            gen.writeNumber("42");
+            gen.writeName("sh");
+            gen.writeNumber((short) 7);
+            gen.writeName("nil");
+            gen.writeNull();
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 string overloads ──────────────────────────────────────
+    @Test
+    public void generator_stringOverloads() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("charArr");
+            gen.writeString("hello".toCharArray(), 0, 5);
+            gen.writeName("sstr");
+            gen.writeString(new tools.jackson.core.io.SerializedString("world"));
+            gen.writeName("utf8");
+            gen.writeUTF8String("hi".getBytes(java.nio.charset.StandardCharsets.UTF_8), 0, 2);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeString(null) covers null-string branch ───────────
+    @Test
+    public void generator_writeNullString() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("nil");
+            gen.writeString((String) null);
+            gen.writeEndObject();
+        }
+    }
+
+    // ── ODINGenerator3 primitive array — covers comma separator ──────────────
+    @Test
+    public void generator_primitiveArrayComma() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("arr");
+            gen.writeStartArray();
+            gen.writeNumber(1);   // first element — STATUS_OK_AS_IS
+            gen.writeNumber(2);   // second element — STATUS_OK_AFTER_COMMA (non-object array)
+            gen.writeEndArray();
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 typeId at root context ─────────────────────────────────
+    @Test
+    public void generator_typeIdAtRoot() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeTypeId("MyType");   // sets _typeId and _typeIdAtRoot at root
+            gen.writeStartObject();
+            gen.writeName("x");
+            gen.writeNumber(1);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 raw write overloads (bypass write context) ────────────
+    @Test
+    public void generator_rawWriteOverloads() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        // writeRaw variants bypass write context — call them outside object/array
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeRaw("hello", 0, 5);
+            gen.writeRaw(new char[]{'w', 'o', 'r', 'l', 'd'}, 0, 5);
+            gen.writeRaw('!');
+        }
+        assertEquals("helloworld!", sw.toString());
+    }
+
+    // ── ODINGenerator3 binary ─────────────────────────────────────────────────
+    @Test
+    public void generator_binary() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("bin");
+            gen.writeBinary(new byte[]{1, 2, 3});
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 flush ──────────────────────────────────────────────────
+    @Test
+    public void generator_flush() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("x");
+            gen.writeNumber(1);
+            gen.writeEndObject();
+            gen.flush();
+        }
+    }
+
+    // ── ODINGenerator3 writeStartArray/Object forValue overloads ─────────────
+    @Test
+    public void generator_startArrayAndObjectForValueOverloads() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("arr");
+            gen.writeStartArray("ignored");
+            gen.writeEndArray();
+            gen.writeName("arr2");
+            gen.writeStartArray("ignored", 0);
+            gen.writeEndArray();
+            gen.writeName("obj");
+            gen.writeStartObject("ignored");
+            gen.writeEndObject();
+            gen.writeName("obj2");
+            gen.writeStartObject("ignored", 0);
+            gen.writeEndObject();
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeObjectId / writeObjectRef ────────────────────────
+    @Test
+    public void generator_objectIdAndRef() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (JsonGenerator gen = factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeObjectId("id-1");
+            gen.writeName("x");
+            gen.writeNumber(1);
+            gen.writeName("ref");
+            gen.writeObjectRef("ref-1");
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeRawValue(String/char[], offset, len) ─────────────
+    @Test
+    public void generator_writeRawValueWithOffset() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("s");
+            gen.writeRawValue("hello", 1, 3);  // "ell"
+            gen.writeName("c");
+            gen.writeRawValue(new char[]{'w', 'o', 'r', 'l', 'd'}, 1, 3);  // "orl"
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeBoolean ───────────────────────────────────────────
+    @Test
+    public void generator_writeBoolean() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("t");
+            gen.writeBoolean(true);
+            gen.writeName("f");
+            gen.writeBoolean(false);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeRawValue(String) ─────────────────────────────────
+    @Test
+    public void generator_writeRawValue() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("raw");
+            gen.writeRawValue("raw_content");
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writePOJO ──────────────────────────────────────────────
+    @Test
+    public void generator_writePOJO() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("pojo");
+            gen.writePOJO(new Object());
+            gen.writeEndObject();
+        }
+    }
+
+    // ── ODINGenerator3 null paths for writeNumber / writeBinary ──────────────
+    @Test
+    public void generator_nullNumberAndBinaryPaths() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("bi");
+            gen.writeNumber((BigInteger) null);
+            gen.writeName("bd");
+            gen.writeNumber((BigDecimal) null);
+            gen.writeName("str");
+            gen.writeNumber((String) null);
+            gen.writeName("bin");
+            gen.writeBinary(Base64Variants.MIME, null, 0, 0);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeBinary with offset ────────────────────────────────
+    @Test
+    public void generator_writeBinaryWithOffset() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("bin");
+            gen.writeBinary(Base64Variants.MIME, new byte[]{0, 1, 2, 3}, 1, 2);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeBinary with non-default Base64 variant ────────────
+    @Test
+    public void generator_writeBinaryNonDefaultVariant() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("bin");
+            gen.writeBinary(Base64Variants.PEM, new byte[]{1, 2, 3}, 0, 3);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 writeNumber(BigDecimal) with WRITE_BIGDECIMAL_AS_PLAIN ─
+    @Test
+    public void generator_writeBigDecimalAsPlain() throws Exception {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("bd", new BigDecimal("1.2E+10"));
+        String result = ODINMapper3.builder()
+                .enable(StreamWriteFeature.WRITE_BIGDECIMAL_AS_PLAIN)
+                .deactivateDefaultTyping()
+                .build()
+                .writeValueAsString(map);
+        assertNotNull(result);
+    }
+
+    // ── ODINGenerator3 error paths — use direct try-catch (not lambda) ────────
+    @Test
+    public void generator_writeNameInValueContext_throws() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), new StringWriter());
+        boolean threw = false;
+        try {
+            gen.writeStartObject();
+            gen.writeName("key");
+            gen.writeName("bad"); // context expects VALUE, not NAME
+        } catch (Exception e) {
+            threw = true;
+        } finally {
+            try { gen.close(); } catch (Exception ignored) {}
+        }
+        assertTrue(threw);
+    }
+
+    @Test
+    public void generator_writeEndArrayOutsideArray_throws() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), new StringWriter());
+        boolean threw = false;
+        try {
+            gen.writeEndArray(); // not in array context
+        } catch (Exception e) {
+            threw = true;
+        } finally {
+            try { gen.close(); } catch (Exception ignored) {}
+        }
+        assertTrue(threw);
+    }
+
+    @Test
+    public void generator_writeEndObjectOutsideObject_throws() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), new StringWriter());
+        boolean threw = false;
+        try {
+            gen.writeEndObject(); // not in object context
+        } catch (Exception e) {
+            threw = true;
+        } finally {
+            try { gen.close(); } catch (Exception ignored) {}
+        }
+        assertTrue(threw);
+    }
+
+    // ── ODINGenerator3 writeTypeId inside nested object ───────────────────────
+    @Test
+    public void generator_typeIdInsideObject() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("nested");
+            gen.writeTypeId("InnerType");  // NOT at root — covers false branch of inRoot()
+            gen.writeStartObject();
+            gen.writeName("x");
+            gen.writeNumber(1);
+            gen.writeEndObject();
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 array of two objects — covers 2nd-object array path ──
+    @Test
+    public void generator_arrayOfTwoObjects() throws Exception {
+        ContainerWithList container = new ContainerWithList();
+        container.setSomeField("test");
+        TestObject obj1 = new TestObject();
+        obj1.setStringField("first");
+        obj1.setIntField(1);
+        TestObject obj2 = new TestObject();
+        obj2.setStringField("second");
+        obj2.setIntField(2);
+        container.addListItem(obj1);
+        container.addListItem(obj2);
+        String result = ODINMapper3.builder().deactivateDefaultTyping().build().writeValueAsString(container);
+        assertNotNull(result);
+    }
+
+    // ── ODINGenerator3 STATUS_OK_AFTER_SPACE — two root values ───────────────
+    @Test
+    public void generator_twoRootValues() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        StringWriter sw = new StringWriter();
+        try (ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), sw)) {
+            gen.writeStartObject();
+            gen.writeName("a");
+            gen.writeNumber(1);
+            gen.writeEndObject();
+            // second root value triggers STATUS_OK_AFTER_SPACE
+            gen.writeStartObject();
+            gen.writeName("b");
+            gen.writeNumber(2);
+            gen.writeEndObject();
+        }
+        assertNotNull(sw.toString());
+    }
+
+    // ── ODINGenerator3 STATUS_EXPECT_NAME — write value where name expected ──
+    @Test
+    public void generator_writeValueWhereNameExpected_throws() throws Exception {
+        ODINFactory3 factory = new ODINFactory3();
+        ODINGenerator3 gen = (ODINGenerator3) factory.createGenerator(ObjectWriteContext.empty(), new StringWriter());
+        boolean threw = false;
+        try {
+            gen.writeStartObject();
+            gen.writeNumber(42); // context expects NAME, triggers STATUS_EXPECT_NAME
+        } catch (Exception e) {
+            threw = true;
+        } finally {
+            try { gen.close(); } catch (Exception ignored) {}
+        }
+        assertTrue(threw);
+    }
+}
diff --git a/odin/src/test/java/org/openehr/odin/jackson/OdinSerializeTest.java b/odin/src/test/java/org/openehr/odin/jackson/OdinSerializeTest.java
index ec4aaff54..1d33a0c54 100644
--- a/odin/src/test/java/org/openehr/odin/jackson/OdinSerializeTest.java
+++ b/odin/src/test/java/org/openehr/odin/jackson/OdinSerializeTest.java
@@ -1,13 +1,34 @@
 package org.openehr.odin.jackson;
 
+import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.openehr.odin.jackson.testclasses.ContainerWithList;
 import org.openehr.odin.jackson.testclasses.TestObject;
+import org.openehr.odin.jackson3.ODINMapper3;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class OdinSerializeTest {
 
-    @Test
-    public void serializeListOfObject() throws Exception {
+    interface OdinMapper {
+        String writeValueAsString(Object value) throws Exception;
+    }
+
+    private static Stream<Arguments> mappers() {
+        return Stream.of(
+                Arguments.of(Named.of("Jackson 2", (OdinMapper) o -> new ODINMapper().writeValueAsString(o))),
+                Arguments.of(Named.of("Jackson 3", (OdinMapper) o -> ODINMapper3.builder().build().writeValueAsString(o)))
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void serializeListOfObject(OdinMapper mapper) throws Exception {
         ContainerWithList listContainer = new ContainerWithList();
         listContainer.setSomeField("some field");
         TestObject testObject = new TestObject();
@@ -20,9 +41,26 @@ public void serializeListOfObject() throws Exception {
         testObject2.setIntField(2);
         listContainer.addListItem(testObject2);
 
-        ODINMapper mapper = new ODINMapper();
-
         String s = mapper.writeValueAsString(listContainer);
         System.out.println(s);
     }
+
+    @Test
+    public void jackson3OutputMatchesJackson2() throws Exception {
+        ContainerWithList listContainer = new ContainerWithList();
+        listContainer.setSomeField("some field");
+        TestObject testObject = new TestObject();
+        testObject.setStringField("test1");
+        testObject.setIntField(1);
+        listContainer.addListItem(testObject);
+
+        TestObject testObject2 = new TestObject();
+        testObject2.setStringField("test2");
+        testObject2.setIntField(2);
+        listContainer.addListItem(testObject2);
+
+        String j2 = new ODINMapper().writeValueAsString(listContainer);
+        String j3 = ODINMapper3.builder().build().writeValueAsString(listContainer);
+        assertEquals(j2, j3);
+    }
 }
diff --git a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDate.java b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDate.java
index 4309bb2c5..8e7fb8df9 100644
--- a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDate.java
+++ b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDate.java
@@ -1,9 +1,7 @@
 package com.nedap.archie.rm.datavalues.quantity.datetime;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.nedap.archie.datetime.DateTimeParsers;
-import com.nedap.archie.json.DateDeserializer;
 import com.nedap.archie.rm.datatypes.CodePhrase;
 import com.nedap.archie.rm.datavalues.SingleValuedDataValue;
 import com.nedap.archie.rm.datavalues.quantity.DvInterval;
@@ -81,7 +79,8 @@ public DvDate(@Nullable List<ReferenceRange<DvDate>> otherReferenceRanges, @Null
 //            @XmlElement(type=Year.class)
 //
 //    })
-    @JsonDeserialize(using= DateDeserializer.class)
+    @com.fasterxml.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json.DateDeserializer.class)
+    @tools.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json3.DateDeserializer.class)
     public Temporal getValue() {
         return value;
     }
diff --git a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDateTime.java b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDateTime.java
index ddcbae6e7..c83818a49 100644
--- a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDateTime.java
+++ b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvDateTime.java
@@ -1,11 +1,7 @@
 package com.nedap.archie.rm.datavalues.quantity.datetime;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.nedap.archie.datetime.DateTimeParsers;
-import com.nedap.archie.json.DateTimeDeserializer;
-import com.nedap.archie.json.DateTimeSerializer;
 import com.nedap.archie.rm.datatypes.CodePhrase;
 import com.nedap.archie.rm.datavalues.SingleValuedDataValue;
 import com.nedap.archie.rm.datavalues.quantity.DvInterval;
@@ -70,8 +66,10 @@ public DvDateTime(@Nullable List<ReferenceRange<DvDateTime>> otherReferenceRange
 //            @XmlElement(type = OffsetDateTime.class),
 //            @XmlElement(type = LocalDateTime.class)
 //    })
-	@JsonSerialize(using = DateTimeSerializer.class)
-	@JsonDeserialize(using = DateTimeDeserializer.class)
+	@com.fasterxml.jackson.databind.annotation.JsonSerialize(using = com.nedap.archie.json.DateTimeSerializer.class)
+	@tools.jackson.databind.annotation.JsonSerialize(using = com.nedap.archie.json3.DateTimeSerializer.class)
+	@com.fasterxml.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json.DateTimeDeserializer.class)
+	@tools.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json3.DateTimeDeserializer.class)
 	public TemporalAccessor getValue() {
 		return value;
 	}
diff --git a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvTime.java b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvTime.java
index 9a761e292..5f052d9f2 100644
--- a/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvTime.java
+++ b/openehr-rm/src/main/java/com/nedap/archie/rm/datavalues/quantity/datetime/DvTime.java
@@ -1,9 +1,7 @@
 package com.nedap.archie.rm.datavalues.quantity.datetime;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.nedap.archie.datetime.DateTimeParsers;
-import com.nedap.archie.json.TimeDeserializer;
 import com.nedap.archie.rm.datatypes.CodePhrase;
 import com.nedap.archie.rm.datavalues.SingleValuedDataValue;
 import com.nedap.archie.rm.datavalues.quantity.DvInterval;
@@ -73,7 +71,8 @@ public void setValue(TemporalAccessor value) {
 //            @XmlElement(type=OffsetTime.class),
 //            @XmlElement(type=LocalTime.class)
 //    })    
-    @JsonDeserialize(using=TimeDeserializer.class)
+    @com.fasterxml.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json.TimeDeserializer.class)
+    @tools.jackson.databind.annotation.JsonDeserialize(using = com.nedap.archie.json3.TimeDeserializer.class)
     public TemporalAccessor getValue() {
         return value;
     }
diff --git a/tools/src/test/java/com/nedap/archie/json/AOMJacksonTest.java b/tools/src/test/java/com/nedap/archie/json/AOMJacksonTest.java
index 2141d067e..385116a22 100644
--- a/tools/src/test/java/com/nedap/archie/json/AOMJacksonTest.java
+++ b/tools/src/test/java/com/nedap/archie/json/AOMJacksonTest.java
@@ -1,8 +1,9 @@
 package com.nedap.archie.json;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
+import com.nedap.archie.json3.JacksonUtil3;
+import com.nedap.archie.json.JacksonTestMappers.JsonMapper;
 import com.google.common.collect.Lists;
 import com.nedap.archie.adlparser.ADLParser;
 import com.nedap.archie.aom.*;
@@ -19,7 +20,11 @@
 import com.nedap.archie.serializer.adl.ADLArchetypeSerializer;
 import com.nedap.archie.testutil.TestUtil;
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.openehr.referencemodels.BuiltinReferenceModels;
 import org.threeten.extra.PeriodDuration;
 
@@ -29,6 +34,7 @@
 import java.time.Duration;
 import java.time.Period;
 import java.time.temporal.ChronoUnit;
+import java.util.stream.Stream;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
@@ -42,10 +48,42 @@
  */
 public class AOMJacksonTest {
 
-    @Test
-    public void parseDeliriumObservationScreening() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream("delirium_observation_screening.json")) {
-            Archetype archetype = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration()).readValue(stream, Archetype.class);
+    interface JsonMapperFactory extends JacksonTestMappers.JsonMapperFactory {
+        JsonMapper createNoIndent(ArchieJacksonConfiguration config);
+    }
+
+    private static Stream<Arguments> mappers() {
+        JsonMapperFactory j2 = new JsonMapperFactory() {
+            public JsonMapper create() { return JacksonTestMappers.wrap(JacksonUtil.getObjectMapper()); }
+            public JsonMapper create(ArchieJacksonConfiguration c) { return JacksonTestMappers.wrap(JacksonUtil.getObjectMapper(c)); }
+            public JsonMapper createNoIndent(ArchieJacksonConfiguration c) {
+                ObjectMapper m = new ObjectMapper();
+                JacksonUtil.configureObjectMapper(m, c);
+                m.disable(SerializationFeature.INDENT_OUTPUT);
+                return JacksonTestMappers.wrap(m);
+            }
+        };
+        JsonMapperFactory j3 = new JsonMapperFactory() {
+            public JsonMapper create() { return JacksonTestMappers.wrap(JacksonUtil3.getObjectMapper()); }
+            public JsonMapper create(ArchieJacksonConfiguration c) { return JacksonTestMappers.wrap(JacksonUtil3.getObjectMapper(c)); }
+            public JsonMapper createNoIndent(ArchieJacksonConfiguration c) {
+                var builder = tools.jackson.databind.json.JsonMapper.builder();
+                JacksonUtil3.configureBuilder(builder, c);
+                builder.disable(tools.jackson.databind.SerializationFeature.INDENT_OUTPUT);
+                return JacksonTestMappers.wrap(builder.build());
+            }
+        };
+        return Stream.of(
+                Arguments.of(Named.of("Jackson 2", j2)),
+                Arguments.of(Named.of("Jackson 3", j3))
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseDeliriumObservationScreening(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("delirium_observation_screening.json")) {
+            Archetype archetype = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration()).readValue(stream, Archetype.class);
             System.out.println(archetype);
             assertTrue(((AuthoredArchetype) archetype).getGenerated());
             assertThat(archetype.getArchetypeId().getFullId(), is("openEHR-EHR-GENERIC_ENTRY.delirium_observation_screening.v1.0.0"));
@@ -59,68 +97,63 @@ public void parseDeliriumObservationScreening() throws Exception {
         }
     }
 
-    @Test
-    public void roundTripDeliriumObservationScreening() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream("delirium_observation_screening.json")) {
-            ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-            Archetype archetype = objectMapper.readValue(stream, Archetype.class);
-            String reserialized = objectMapper.writeValueAsString(archetype);
-            //System.out.println(reserialized);
-            objectMapper.readValue(reserialized, Archetype.class);
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void roundTripDeliriumObservationScreening(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("delirium_observation_screening.json")) {
+            JsonMapper mapper = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration());
+            Archetype archetype = mapper.readValue(stream, Archetype.class);
+            String reserialized = mapper.writeValueAsString(archetype);
+            mapper.readValue(reserialized, Archetype.class);
         }
     }
 
-    @Test
-    public void parseLifecycleStateStringTest() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-        String resourceDescriptionJson = "{ \"lifecycle_state\" :\"unmanaged\" }";
-        ResourceDescription resourceDescription = objectMapper.readValue(resourceDescriptionJson, ResourceDescription.class);
-        // assert that the lifecycle state is set to unmanaged
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseLifecycleStateStringTest(JsonMapperFactory factory) throws Exception {
+        ResourceDescription resourceDescription = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration())
+                .readValue("{ \"lifecycle_state\" :\"unmanaged\" }", ResourceDescription.class);
         assertEquals("unmanaged", resourceDescription.getLifecycleState());
     }
 
-    @Test
-    public void parseLifecycleStateTerminologyCodeTest() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-        String resourceDescriptionJson = "{ \"lifecycle_state\" : { \"code_string\" : \"unmanaged\" }}";
-        ResourceDescription resourceDescription = objectMapper.readValue(resourceDescriptionJson, ResourceDescription.class);
-        // assert that the lifecycle state is set to unmanaged
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseLifecycleStateTerminologyCodeTest(JsonMapperFactory factory) throws Exception {
+        ResourceDescription resourceDescription = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration())
+                .readValue("{ \"lifecycle_state\" : { \"code_string\" : \"unmanaged\" }}", ResourceDescription.class);
         assertEquals("unmanaged", resourceDescription.getLifecycleState());
     }
 
-    @Test
-    public void parseLifecycleStateTerminologyCodeCodeStringNullTest() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-        String resourceDescriptionJson = "{ \"lifecycle_state\" : { \"code_string\" : null }}";
-        ResourceDescription resourceDescription = objectMapper.readValue(resourceDescriptionJson, ResourceDescription.class);
-        // assert that the lifecycle state is set to unmanaged
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseLifecycleStateTerminologyCodeCodeStringNullTest(JsonMapperFactory factory) throws Exception {
+        ResourceDescription resourceDescription = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration())
+                .readValue("{ \"lifecycle_state\" : { \"code_string\" : null }}", ResourceDescription.class);
         assertNull(resourceDescription.getLifecycleState());
     }
 
-    @Test
-    public void parseLifecycleStateTerminologyCodeNoCodeStringTest() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-        String resourceDescriptionJson = "{ \"lifecycle_state\" : { \"placeholder\" : \"placeholder\" }}";
-        ResourceDescription resourceDescription = objectMapper.readValue(resourceDescriptionJson, ResourceDescription.class);
-        // assert that the lifecycle state is set to unmanaged
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseLifecycleStateTerminologyCodeNoCodeStringTest(JsonMapperFactory factory) throws Exception {
+        ResourceDescription resourceDescription = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration())
+                .readValue("{ \"lifecycle_state\" : { \"placeholder\" : \"placeholder\" }}", ResourceDescription.class);
         assertNull(resourceDescription.getLifecycleState());
     }
 
-    @Test
-    public void parseLifecycleStateArrayTest() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createLegacyConfiguration());
-        String resourceDescriptionJson = "{ \"lifecycle_state\" : [] }";
-        ResourceDescription resourceDescription = objectMapper.readValue(resourceDescriptionJson, ResourceDescription.class);
-        // assert that the lifecycle state is set to unmanaged
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseLifecycleStateArrayTest(JsonMapperFactory factory) throws Exception {
+        ResourceDescription resourceDescription = factory.create(ArchieJacksonConfiguration.createLegacyConfiguration())
+                .readValue("{ \"lifecycle_state\" : [] }", ResourceDescription.class);
         assertNull(resourceDescription.getLifecycleState());
     }
 
-    @Test
-    public void motricityIndex() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void motricityIndex(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
             Archetype archetype = new ADLParser(BuiltinReferenceModels.getMetaModelProvider()).parse(stream);
-            String serialized = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant()).writeValueAsString(archetype);
-            //System.out.println(serialized);
+            String serialized = factory.create(ArchieJacksonConfiguration.createStandardsCompliant()).writeValueAsString(archetype);
             assertTrue(serialized.contains("EXPR_BINARY_OPERATOR"));
             assertTrue(serialized.contains("\"operator_def\" : {\n" +
                     "          \"_type\" : \"OPERATOR_DEF_BUILTIN\",\n" +
@@ -128,92 +161,80 @@ public void motricityIndex() throws Exception {
                     "        }"));
             assertTrue(serialized.contains("EXPR_ARCHETYPE_REF"));
             assertTrue(serialized.contains("\"rules\" : [ {"));
-            Archetype parsedArchetype = JacksonUtil.getObjectMapper().readValue(serialized, Archetype.class);
+            Archetype parsedArchetype = factory.create().readValue(serialized, Archetype.class);
             assertEquals(8, parsedArchetype.getRules().getRules().size());
 
             ArchieJacksonConfiguration newConfig = ArchieJacksonConfiguration.createStandardsCompliant();
             newConfig.setStandardsCompliantExpressions(false);
-            Archetype parsedArchetype2 = JacksonUtil.getObjectMapper(newConfig).readValue(serialized, Archetype.class);
+            Archetype parsedArchetype2 = factory.create(newConfig).readValue(serialized, Archetype.class);
             assertEquals(8, parsedArchetype2.getRules().getRules().size());
         }
     }
 
-    /**
-     * Parse the old json format, but with rules as a direct list instead of a RulesSection objeet in between.
-     * @throws Exception
-     */
-    @Test
-    public void motricityIndexRulesOldFormatAsList() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream("motricity_index_legacy_format_rules_section_as_array.json")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void motricityIndexRulesOldFormatAsList(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("motricity_index_legacy_format_rules_section_as_array.json")) {
             ArchieJacksonConfiguration config = ArchieJacksonConfiguration.createStandardsCompliant();
             config.setStandardsCompliantExpressions(false);
-            Archetype parsedArchetype = JacksonUtil.getObjectMapper(config).readValue(stream, Archetype.class);
+            Archetype parsedArchetype = factory.create(config).readValue(stream, Archetype.class);
             assertEquals(8, parsedArchetype.getRules().getRules().size());
-
         }
     }
 
-    /**
-     * Parse the old json format, but with rules as a direct list instead of a RulesSection objeet in between.
-     * @throws Exception
-     */
-    @Test
-    public void motriciyIndexJavascriptFormat() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void motriciyIndexJavascriptFormat(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
             Archetype archetype = new ADLParser(BuiltinReferenceModels.getMetaModelProvider()).parse(stream);
-            String serialized = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createConfigForJavascriptUsage()).writeValueAsString(archetype);
-            //System.out.println(serialized);
+            String serialized = factory.create(ArchieJacksonConfiguration.createConfigForJavascriptUsage()).writeValueAsString(archetype);
             assertTrue(serialized.contains("EXPR_BINARY_OPERATOR"));
             assertTrue(serialized.contains("EXPR_ARCHETYPE_REF"));
             assertTrue(serialized.contains("\"rules\" : [ {"));
-            Archetype parsedArchetype = JacksonUtil.getObjectMapper().readValue(serialized, Archetype.class);
+            Archetype parsedArchetype = factory.create().readValue(serialized, Archetype.class);
             assertEquals(8, parsedArchetype.getRules().getRules().size());
 
             ArchieJacksonConfiguration newConfig = ArchieJacksonConfiguration.createStandardsCompliant();
             newConfig.setStandardsCompliantExpressions(false);
-            Archetype parsedArchetype2 = JacksonUtil.getObjectMapper(newConfig).readValue(serialized, Archetype.class);
+            Archetype parsedArchetype2 = factory.create(newConfig).readValue(serialized, Archetype.class);
             assertEquals(8, parsedArchetype2.getRules().getRules().size());
         }
     }
 
-
-    @Test
-    public void motricityIndexOldFormat() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void motricityIndexOldFormat(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/com/nedap/archie/rules/evaluation/openEHR-EHR-OBSERVATION.motricity_index.v1.0.0.adls")) {
             Archetype archetype = new ADLParser(BuiltinReferenceModels.getMetaModelProvider()).parse(stream);
             ArchieJacksonConfiguration config = ArchieJacksonConfiguration.createStandardsCompliant();
             config.setStandardsCompliantExpressions(false);
-            String serialized = JacksonUtil.getObjectMapper(config).writeValueAsString(archetype);
+            String serialized = factory.create(config).writeValueAsString(archetype);
             System.out.println(serialized);
             assertTrue(serialized.contains("\"BINARY_OPERATOR\""));
             assertTrue(serialized.contains("\"operator\" : \"eq\","));
             assertTrue(serialized.contains("\"MODEL_REFERENCE\""));
             assertTrue(serialized.contains("\"rules\" : {"));
-            ArchieJacksonConfiguration newConfig = ArchieJacksonConfiguration.createStandardsCompliant();
-            newConfig.setStandardsCompliantExpressions(true);
-            Archetype parsedArchetype = JacksonUtil.getObjectMapper(config).readValue(serialized, Archetype.class);
+            Archetype parsedArchetype = factory.create(config).readValue(serialized, Archetype.class);
             assertEquals(8, parsedArchetype.getRules().getRules().size());
         }
     }
 
-    @Test
-    public void archetypeSlot() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/basic.adl")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void archetypeSlot(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/basic.adl")) {
             Archetype archetype = new ADLParser(BuiltinReferenceModels.getMetaModelProvider()).parse(stream);
-            ObjectMapper objectMapper = new ObjectMapper();
-            JacksonUtil.configureObjectMapper(objectMapper, ArchieJacksonConfiguration.createStandardsCompliant());
-            objectMapper.disable(SerializationFeature.INDENT_OUTPUT);
-            String serialized = objectMapper.writeValueAsString(archetype);
-            //System.out.println(serialized);
+            JsonMapper mapper = factory.createNoIndent(ArchieJacksonConfiguration.createStandardsCompliant());
+            String serialized = mapper.writeValueAsString(archetype);
             assertTrue(serialized.contains("\"EXPR_BINARY_OPERATOR\""));
             assertTrue(serialized.contains("\"EXPR_ARCHETYPE_REF\""));
             assertTrue(serialized.contains("\"operator_def\":{\"_type\":\"OPERATOR_DEF_BUILTIN\",\"identifier\":\"op_matches\"}"));
-            assertArchetypeSlot(objectMapper, serialized);
+            assertArchetypeSlot(mapper, serialized);
         }
     }
 
-    private void assertArchetypeSlot(ObjectMapper objectMapper, String serialized) throws JsonProcessingException {
-        Archetype parsedArchetype = objectMapper.readValue(serialized, Archetype.class);
+    private void assertArchetypeSlot(JsonMapper mapper, String serialized) throws Exception {
+        Archetype parsedArchetype = mapper.readValue(serialized, Archetype.class);
         ArchetypeSlot slot = parsedArchetype.itemAtPath("/content[id8]");
         BinaryOperator operator = (BinaryOperator) slot.getIncludes().get(0).getExpression();
         assertEquals(OperatorKind.matches, operator.getOperator());
@@ -222,119 +243,118 @@ private void assertArchetypeSlot(ObjectMapper objectMapper, String serialized) t
         assertEquals("/openEHR-EHR-INSTRUCTION\\.medication\\.v1/", idConstraint.getConstraint().get(0));
     }
 
-    @Test
-    public void archetypeSlotOldExpressionClassNames() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/basic.adl")) {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void archetypeSlotOldExpressionClassNames(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/basic.adl")) {
             Archetype archetype = new ADLParser(BuiltinReferenceModels.getMetaModelProvider()).parse(stream);
             ArchieJacksonConfiguration config = ArchieJacksonConfiguration.createStandardsCompliant();
             config.setStandardsCompliantExpressions(false);
-            ObjectMapper objectMapper = JacksonUtil.getObjectMapper(config);
-            String serialized = objectMapper.writeValueAsString(archetype);
+            JsonMapper mapper = factory.create(config);
+            String serialized = mapper.writeValueAsString(archetype);
             System.out.println(serialized);
             assertFalse(serialized.contains("EXPR_BINARY_OPERATOR"));
             assertFalse(serialized.contains("EXPR_ARCHETYPE_REF"));
             assertTrue(serialized.contains("\"operator\" : \"matches\","));
             assertTrue(serialized.contains("\"BINARY_OPERATOR\""));
             assertTrue(serialized.contains("\"MODEL_REFERENCE\""));
-            assertArchetypeSlot(objectMapper, serialized);
-            //and it should be parsable with the new syntax as well
-            assertArchetypeSlot(JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant()), serialized);
-
+            assertArchetypeSlot(mapper, serialized);
+            assertArchetypeSlot(factory.create(ArchieJacksonConfiguration.createStandardsCompliant()), serialized);
         }
     }
 
-
-    @Test
-    public void cDuration() throws Exception {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void cDuration(JsonMapperFactory factory) throws Exception {
         CDuration cDuration = new CDuration();
         cDuration.addConstraint(new Interval<>(Duration.of(-10, ChronoUnit.HOURS), Duration.of(10, ChronoUnit.SECONDS)));
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
-        String cDurationJson = objectMapper.writeValueAsString(cDuration);
+        JsonMapper mapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
+        String cDurationJson = mapper.writeValueAsString(cDuration);
         assertTrue(cDurationJson.contains("-PT10H"));
         assertTrue(cDurationJson.contains("PT10S"));
         System.out.println(cDurationJson);
-
-        CDuration parsedDuration = objectMapper.readValue(cDurationJson, CDuration.class);
+        CDuration parsedDuration = mapper.readValue(cDurationJson, CDuration.class);
         assertEquals(Lists.newArrayList(new Interval<>(Duration.of(-10, ChronoUnit.HOURS), Duration.of(10, ChronoUnit.SECONDS))), parsedDuration.getConstraint());
     }
 
-    @Test
-    public void cDurationPeriodDuration() throws Exception {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void cDurationPeriodDuration(JsonMapperFactory factory) throws Exception {
         CDuration cDuration = new CDuration();
         PeriodDuration tenYearsTenSeconds = PeriodDuration.of(Period.of(10, 0, 0), Duration.of(10, ChronoUnit.SECONDS));
         cDuration.addConstraint(new Interval<>(Duration.of(-10, ChronoUnit.HOURS), tenYearsTenSeconds));
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
-        String cDurationJson = objectMapper.writeValueAsString(cDuration);
+        JsonMapper mapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
+        String cDurationJson = mapper.writeValueAsString(cDuration);
         assertTrue(cDurationJson.contains("-PT10H"));
         assertTrue(cDurationJson.contains("P10YT10S"));
         System.out.println(cDurationJson);
-
-        CDuration parsedDuration = objectMapper.readValue(cDurationJson, CDuration.class);
+        CDuration parsedDuration = mapper.readValue(cDurationJson, CDuration.class);
         assertEquals(Lists.newArrayList(new Interval<>(Duration.of(-10, ChronoUnit.HOURS), tenYearsTenSeconds)), parsedDuration.getConstraint());
     }
 
-    @Test
-    public void cTerminologyCode() throws Exception {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void cTerminologyCode(JsonMapperFactory factory) throws Exception {
         CTerminologyCode cTermCode = new CTerminologyCode();
         cTermCode.setConstraint("ac23");
         cTermCode.setConstraintStatus(ConstraintStatus.PREFERRED);
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
-        String json = objectMapper.writeValueAsString(cTermCode);
-
+        JsonMapper mapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
+        String json = mapper.writeValueAsString(cTermCode);
         assertTrue(json.contains("\"constraint_status\" : \"preferred\""));
         assertTrue(json.contains("\"constraint\" : \"ac23\""));
-        CTerminologyCode parsedTermCode = objectMapper.readValue(json, CTerminologyCode.class);
+        CTerminologyCode parsedTermCode = mapper.readValue(json, CTerminologyCode.class);
         assertEquals(cTermCode.getConstraint(), parsedTermCode.getConstraint());
         assertEquals(ConstraintStatus.PREFERRED, parsedTermCode.getConstraintStatus());
     }
 
-    @Test
-    public void backwardsCompatibilityCTerminologyCodeConstraintTypeFromJsonTest() throws Exception {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void backwardsCompatibilityCTerminologyCodeConstraintTypeFromJsonTest(JsonMapperFactory factory) throws Exception {
         String json = "{\n" +
                 "  \"rm_type_name\" : \"terminology_code\",\n" +
                 "  \"node_id\" : \"id9999\",\n" +
                 "  \"constraint\" : [ \"ac23\" ]\n" +
                 "}";
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
-        CTerminologyCode parsedTermCode = objectMapper.readValue(json, CTerminologyCode.class);
+        CTerminologyCode parsedTermCode = factory.create(ArchieJacksonConfiguration.createStandardsCompliant()).readValue(json, CTerminologyCode.class);
         assertEquals("ac23", parsedTermCode.getConstraint());
     }
 
-    @Test
-    public void rmOverlay() throws Exception {
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void rmOverlay(JsonMapperFactory factory) throws Exception {
         Archetype archetype = TestUtil.parseFailOnErrors("/com/nedap/archie/flattener/openEHR-EHR-OBSERVATION.to_flatten_parent_with_overlay.v1.0.0.adls");
-        String json = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant()).writeValueAsString(archetype);
-
-        Archetype parsed = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant()).readValue(json, Archetype.class);
+        JsonMapper mapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
+        String json = mapper.writeValueAsString(archetype);
+        Archetype parsed = mapper.readValue(json, Archetype.class);
         assertEquals(VisibilityType.HIDE, parsed.getRmOverlay().getRmVisibility().get("/subject").getVisibility());
         assertEquals("at12", parsed.getRmOverlay().getRmVisibility().get("/subject").getAlias().getCodeString());
 
-        assertTrue(json.contains("  \"rm_overlay\" : {\n" +
-                "    \"rm_visibility\" : {\n" +
-                "      \"/subject\" : {\n" +
-                "        \"visibility\" : \"hide\",\n" +
-                "        \"alias\" : {\n" +
-                "          \"@type\" : \"TerminologyCode\",\n" +
-                "          \"terminology_id\" : \"local\",\n" +
-                "          \"code_string\" : \"at12\",\n" +
-                "          \"terminology_id_string\" : \"local\"\n" +
-                "        }\n" +
-                "      },\n" +
-                "      \"/data[id2]/events[id3]/data[id4]/items[id5]\" : {\n" +
-                "        \"visibility\" : \"show\"\n" +
-                "      },\n" +
-                "      \"/data[id2]/events[id3]/data[id4]/items[id6]\" : {\n" +
-                "        \"visibility\" : \"show\"\n" +
-                "      }\n" +
-                "    }\n" +
-                "  },"));
+        assertEquals(VisibilityType.SHOW, parsed.getRmOverlay().getRmVisibility().get("/data[id2]/events[id3]/data[id4]/items[id5]").getVisibility());
+        assertEquals(VisibilityType.SHOW, parsed.getRmOverlay().getRmVisibility().get("/data[id2]/events[id3]/data[id4]/items[id6]").getVisibility());
+        // J2 and J3 serialize alias fields identically; only field order within /subject differs
+        assertTrue(json.contains("""
+                "alias" : {
+                  "@type" : "TerminologyCode",
+                  "terminology_id" : "local",
+                  "code_string" : "at12",
+                  "terminology_id_string" : "local"
+                }
+        """.stripTrailing()));
+        assertTrue(json.contains("""
+              "/data[id2]/events[id3]/data[id4]/items[id5]" : {
+                "visibility" : "show"
+              },
+              "/data[id2]/events[id3]/data[id4]/items[id6]" : {
+                "visibility" : "show"
+              }
+        """.stripTrailing()));
     }
 
-    @Test
-    public void parseS2AomJson() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream( "/S2/json/flat/s2-EHR-Action.medication.v1.2.2.json")) {
-
-            Archetype parsed = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant()).readValue(stream, Archetype.class);
+    @ParameterizedTest
+    @MethodSource("mappers")
+    public void parseS2AomJson(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("/S2/json/flat/s2-EHR-Action.medication.v1.2.2.json")) {
+            Archetype parsed = factory.create(ArchieJacksonConfiguration.createStandardsCompliant()).readValue(stream, Archetype.class);
             assertNotNull(parsed);
         }
     }
@@ -342,9 +362,7 @@ public void parseS2AomJson() throws Exception {
     @Disabled // for local testing
     @Test
     public void parseS2AomJsonAll() throws Exception {
-
         ObjectMapper mapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
-
         Files.find(new File("../../ADL-exported/S2-S2_demo/json/flat").toPath(),
                         1,
                         (file, att) -> file.toString().endsWith(".json"))
@@ -358,5 +376,4 @@ public void parseS2AomJsonAll() throws Exception {
                     }
                 });
     }
-
 }
diff --git a/tools/src/test/java/com/nedap/archie/json/JacksonRMRoundTripTest.java b/tools/src/test/java/com/nedap/archie/json/JacksonRMRoundTripTest.java
index 9d5a446b5..d6a1ff927 100644
--- a/tools/src/test/java/com/nedap/archie/json/JacksonRMRoundTripTest.java
+++ b/tools/src/test/java/com/nedap/archie/json/JacksonRMRoundTripTest.java
@@ -1,9 +1,10 @@
 package com.nedap.archie.json;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.nedap.archie.adlparser.ADLParser;
 import com.nedap.archie.adlparser.modelconstraints.RMConstraintImposer;
 import com.nedap.archie.aom.Archetype;
+import com.nedap.archie.json.JacksonTestMappers.JsonMapper;
+import com.nedap.archie.json.JacksonTestMappers.JsonMapperFactory;
 import com.nedap.archie.query.RMQueryContext;
 import com.nedap.archie.rm.RMObject;
 import com.nedap.archie.rm.composition.Composition;
@@ -20,7 +21,8 @@
 import com.nedap.archie.testutil.TestUtil;
 import com.nedap.archie.xml.JAXBUtil;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.InputStream;
 import java.net.URI;
@@ -40,7 +42,6 @@
 public class JacksonRMRoundTripTest {
 
     private ADLParser parser;
-
     private TestUtil testUtil;
 
     @BeforeEach
@@ -49,10 +50,11 @@ public void setup() {
         parser = new ADLParser(new RMConstraintImposer());
     }
 
-    @Test
-    public void dataValues() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void dataValues(JsonMapperFactory factory) throws Exception {
         Archetype archetype = parser.parse(JacksonRMRoundTripTest.class.getResourceAsStream("openEHR-EHR-CLUSTER.datavalues.v1.adls"));
-        Cluster cluster =  (Cluster) testUtil.constructEmptyRMObject(archetype.getDefinition());
+        Cluster cluster = (Cluster) testUtil.constructEmptyRMObject(archetype.getDefinition());
         UIDBasedId uid = new HierObjectId();
         uid.setValue("SOME_UUID");
         cluster.setUid(uid);
@@ -73,9 +75,9 @@ public void dataValues() throws Exception {
         DvURI uri = queryContext.find("/items['Uri']/value");
         uri.setValue(URI.create("http://test.example.com"));
 
-        String json = JacksonUtil.getObjectMapper().writeValueAsString(cluster);
-        System.out.println(json);
-        Cluster parsedCluster = (Cluster) JacksonUtil.getObjectMapper().readValue(json, Cluster.class);
+        JsonMapper mapper = factory.create();
+        String json = mapper.writeValueAsString(cluster);
+        Cluster parsedCluster = mapper.readValue(json, Cluster.class);
         RMQueryContext parsedQueryContext = getQueryContext(parsedCluster);
 
         assertThat(parsedQueryContext.<DvText>find("/items['Text']/value").getValue(), is("test-text"));
@@ -86,15 +88,15 @@ public void dataValues() throws Exception {
         assertThat(parsedQueryContext.<DvURI>find("/items['Uri']/value").getValue(), is(URI.create("http://test.example.com")));
         assertThat(parsedCluster.getUid().getValue(), is("SOME_UUID"));
         assertThat(parsedCluster.getArchetypeNodeId(), is("id1"));
-
     }
 
     private RMQueryContext getQueryContext(Cluster cluster) {
         return new RMQueryContext(ArchieRMInfoLookup.getInstance(), cluster, JAXBUtil.getArchieJAXBContext());
     }
 
-    @Test
-    public void composition() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void composition(JsonMapperFactory factory) throws Exception {
         Composition composition = new Composition();
         composition.setCategory("persistent", "openEhr::123");
         composition.setTerritory("openEhr::456");
@@ -103,7 +105,7 @@ public void composition() throws Exception {
         //include the type property name so we can parse it as an RmObject here.
         config.setAlwaysIncludeTypeProperty(true);
 
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper();
+        JsonMapper objectMapper = factory.create();
         String json = objectMapper.writeValueAsString(composition);
 
         Composition parsedComposition = (Composition) objectMapper.readValue(json, Composition.class);
@@ -113,19 +115,14 @@ public void composition() throws Exception {
 
     }
 
-    /**
-     * Parse a 0.5.5 archie generated json and make sure it parses
-     */
-    @Test
-    public void check055BackwardsCompatibility() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void check055BackwardsCompatibility(JsonMapperFactory factory) throws Exception {
         InputStream stream = getClass().getResourceAsStream("rm_object.json");
         ArchieJacksonConfiguration standardsCompliant = ArchieJacksonConfiguration.createStandardsCompliant();
         //unfortunately, we cannot handle two different type propety names
         //that is sort of possible in jackson, but would require overriding internal jackson classes
         standardsCompliant.setTypePropertyName("@type");
-        JacksonUtil.getObjectMapper(standardsCompliant).readValue(stream, RMObject.class);
-
+        factory.create(standardsCompliant).readValue(stream, RMObject.class);
     }
-
-
 }
diff --git a/tools/src/test/java/com/nedap/archie/json/JacksonTestMappers.java b/tools/src/test/java/com/nedap/archie/json/JacksonTestMappers.java
new file mode 100644
index 000000000..ab0727d3e
--- /dev/null
+++ b/tools/src/test/java/com/nedap/archie/json/JacksonTestMappers.java
@@ -0,0 +1,57 @@
+package com.nedap.archie.json;
+
+import com.nedap.archie.json3.JacksonUtil3;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.provider.Arguments;
+
+import java.io.InputStream;
+import java.util.stream.Stream;
+
+/**
+ * Shared test utilities for parameterized tests that run against both Jackson 2 and Jackson 3.
+ * Use {@link #mappers()} as a {@code @MethodSource} to get both mappers as test arguments.
+ */
+public class JacksonTestMappers {
+
+    public interface JsonMapper {
+        <T> T readValue(String content, Class<T> type) throws Exception;
+        <T> T readValue(InputStream src, Class<T> type) throws Exception;
+        String writeValueAsString(Object value) throws Exception;
+    }
+
+    public interface JsonMapperFactory {
+        JsonMapper create();
+        JsonMapper create(ArchieJacksonConfiguration config);
+    }
+
+    public static JsonMapper wrap(com.fasterxml.jackson.databind.ObjectMapper m) {
+        return new JsonMapper() {
+            public <T> T readValue(String s, Class<T> t) throws Exception { return m.readValue(s, t); }
+            public <T> T readValue(InputStream s, Class<T> t) throws Exception { return m.readValue(s, t); }
+            public String writeValueAsString(Object o) throws Exception { return m.writeValueAsString(o); }
+        };
+    }
+
+    public static JsonMapper wrap(tools.jackson.databind.ObjectMapper m) {
+        return new JsonMapper() {
+            public <T> T readValue(String s, Class<T> t) { return m.readValue(s, t); }
+            public <T> T readValue(InputStream s, Class<T> t) { return m.readValue(s, t); }
+            public String writeValueAsString(Object o) { return m.writeValueAsString(o); }
+        };
+    }
+
+    public static Stream<Arguments> mappers() {
+        JsonMapperFactory j2 = new JsonMapperFactory() {
+            public JsonMapper create() { return wrap(JacksonUtil.getObjectMapper()); }
+            public JsonMapper create(ArchieJacksonConfiguration c) { return wrap(JacksonUtil.getObjectMapper(c)); }
+        };
+        JsonMapperFactory j3 = new JsonMapperFactory() {
+            public JsonMapper create() { return wrap(JacksonUtil3.getObjectMapper()); }
+            public JsonMapper create(ArchieJacksonConfiguration c) { return wrap(JacksonUtil3.getObjectMapper(c)); }
+        };
+        return Stream.of(
+                Arguments.of(Named.of("Jackson 2", j2)),
+                Arguments.of(Named.of("Jackson 3", j3))
+        );
+    }
+}
diff --git a/tools/src/test/java/com/nedap/archie/json/OdinParsingConverterTest.java b/tools/src/test/java/com/nedap/archie/json/OdinParsingConverterTest.java
new file mode 100644
index 000000000..c129b6e72
--- /dev/null
+++ b/tools/src/test/java/com/nedap/archie/json/OdinParsingConverterTest.java
@@ -0,0 +1,72 @@
+package com.nedap.archie.json;
+
+import com.nedap.archie.odin3.ItemMapToListConverter;
+import com.nedap.archie.odin3.TermMappingMapToListConverter;
+import com.nedap.archie.rm.datastructures.Element;
+import com.nedap.archie.rm.datastructures.Item;
+import com.nedap.archie.rm.datavalues.DvText;
+import com.nedap.archie.rm.datavalues.TermMapping;
+import org.junit.jupiter.api.Test;
+import tools.jackson.databind.json.JsonMapper;
+import tools.jackson.databind.type.TypeFactory;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for the Jackson 3 ODIN-parsing converters, which convert ODIN-style maps-as-lists
+ * to proper Java lists for apps that register the OdinParsing*Mixin interfaces on a Jackson 3 mapper.
+ */
+public class OdinParsingConverterTest {
+
+    @Test
+    public void itemMapToListConverter_convertsMapToList() {
+        ItemMapToListConverter converter = new ItemMapToListConverter();
+        Map<Integer, Item> map = new LinkedHashMap<>();
+        Element elem = new Element("id1", new DvText("test"), null);
+        map.put(1, elem);
+        List<Item> result = converter.convert(map);
+        assertEquals(1, result.size());
+        assertSame(elem, result.get(0));
+    }
+
+    @Test
+    public void itemMapToListConverter_nullReturnsNull() {
+        assertNull(new ItemMapToListConverter().convert(null));
+    }
+
+    @Test
+    public void itemMapToListConverter_typeMetadata() {
+        ItemMapToListConverter converter = new ItemMapToListConverter();
+        TypeFactory tf = JsonMapper.builder().build().getTypeFactory();
+        assertNotNull(converter.getInputType(tf));
+        assertNotNull(converter.getOutputType(tf));
+    }
+
+    @Test
+    public void termMappingMapToListConverter_convertsMapToList() {
+        TermMappingMapToListConverter converter = new TermMappingMapToListConverter();
+        Map<Integer, TermMapping> map = new LinkedHashMap<>();
+        TermMapping mapping = new TermMapping();
+        map.put(1, mapping);
+        List<TermMapping> result = converter.convert(map);
+        assertEquals(1, result.size());
+        assertSame(mapping, result.get(0));
+    }
+
+    @Test
+    public void termMappingMapToListConverter_nullReturnsNull() {
+        assertNull(new TermMappingMapToListConverter().convert(null));
+    }
+
+    @Test
+    public void termMappingMapToListConverter_typeMetadata() {
+        TermMappingMapToListConverter converter = new TermMappingMapToListConverter();
+        TypeFactory tf = JsonMapper.builder().build().getTypeFactory();
+        assertNotNull(converter.getInputType(tf));
+        assertNotNull(converter.getOutputType(tf));
+    }
+}
diff --git a/tools/src/test/java/com/nedap/archie/json/RMJacksonTest.java b/tools/src/test/java/com/nedap/archie/json/RMJacksonTest.java
index 27ea8ff9c..8a0fa53f9 100644
--- a/tools/src/test/java/com/nedap/archie/json/RMJacksonTest.java
+++ b/tools/src/test/java/com/nedap/archie/json/RMJacksonTest.java
@@ -1,12 +1,14 @@
 package com.nedap.archie.json;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import com.nedap.archie.json.JacksonTestMappers.JsonMapper;
+import com.nedap.archie.json.JacksonTestMappers.JsonMapperFactory;
 import com.nedap.archie.rm.composition.Composition;
 import com.nedap.archie.rm.datavalues.DvText;
 import com.nedap.archie.rm.datavalues.quantity.datetime.DvDateTime;
 import com.nedap.archie.rm.datavalues.quantity.datetime.DvDuration;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.threeten.extra.PeriodDuration;
 
 import java.io.InputStream;
@@ -21,91 +23,88 @@
 
 public class RMJacksonTest {
 
-    @Test
-    public void parseEhrBaseJsonExample() throws Exception {
-        try(InputStream stream = getClass().getResourceAsStream("pablos_example.json")) {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void parseEhrBaseJsonExample(JsonMapperFactory factory) throws Exception {
+        try (InputStream stream = getClass().getResourceAsStream("pablos_example.json")) {
             ArchieJacksonConfiguration configuration = ArchieJacksonConfiguration.createStandardsCompliant();
-            Composition parsed = JacksonUtil.getObjectMapper(configuration).readValue(stream, Composition.class);
+            Composition parsed = factory.create(configuration).readValue(stream, Composition.class);
             assertEquals("__THIS_SHOULD_BE_MODIFIED_BY_THE_TEST_::piri.ehrscape.com::1", parsed.getUid().getValue());
             assertEquals("openEHR-EHR-COMPOSITION.report-mnd.v1", parsed.getArchetypeNodeId());
 
-
-            String json = JacksonUtil.getObjectMapper(configuration).writeValueAsString(parsed);
-            ObjectMapper simpleMapper = new ObjectMapper();
-            LinkedHashMap mapped = simpleMapper.readValue(json, LinkedHashMap.class);
+            String json = factory.create(configuration).writeValueAsString(parsed);
+            LinkedHashMap mapped = new com.fasterxml.jackson.databind.ObjectMapper().readValue(json, LinkedHashMap.class);
             assertEquals("openEHR-EHR-COMPOSITION.report-mnd.v1", mapped.get("archetype_node_id"));
             Map uidMap = (Map) mapped.get("uid");
             assertEquals("__THIS_SHOULD_BE_MODIFIED_BY_THE_TEST_::piri.ehrscape.com::1", uidMap.get("value"));
         }
     }
 
-    @Test
-    public void parseDuration() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void parseDuration(JsonMapperFactory factory) throws Exception {
         String json = "{\n" +
                 "  \"_type\": \"DV_DURATION\",\n" +
                 "  \"value\": \"PT12H20S\"\n" +
                 "}";
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
+        JsonMapper objectMapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
         DvDuration dvDuration = objectMapper.readValue(json, DvDuration.class);
         assertEquals(Duration.parse("PT12H20S"), dvDuration.getValue());
-
         String s = objectMapper.writeValueAsString(dvDuration);
         assertTrue(s.contains("PT12H20S"));
     }
 
-    @Test
-    public void parseNegativeDuration() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void parseNegativeDuration(JsonMapperFactory factory) throws Exception {
         String json = "{\n" +
                 "  \"_type\": \"DV_DURATION\",\n" +
                 "  \"value\": \"-PT12H20S\"\n" +
                 "}";
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
+        JsonMapper objectMapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
         DvDuration dvDuration = objectMapper.readValue(json, DvDuration.class);
         assertEquals(Duration.parse("-PT12H20S"), dvDuration.getValue());
-
         String s = objectMapper.writeValueAsString(dvDuration);
         assertTrue(s.contains("-PT12H20S"));
     }
 
-    @Test
-    public void parsePeriodDuration() throws Exception {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void parsePeriodDuration(JsonMapperFactory factory) throws Exception {
         String json = "{\n" +
                 "  \"_type\": \"DV_DURATION\",\n" +
                 "  \"value\": \"-P10Y10DT12H20S\"\n" +
                 "}";
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
+        JsonMapper objectMapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
         DvDuration dvDuration = objectMapper.readValue(json, DvDuration.class);
         assertEquals(PeriodDuration.parse("-P10Y10DT12H20S"), dvDuration.getValue());
-
         String s = objectMapper.writeValueAsString(dvDuration);
         assertTrue(s.contains("-P10Y10DT12H20S"));
     }
 
-    @Test
-    public void emptyDvTextIsIncluded() throws JsonProcessingException {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void emptyDvTextIsIncluded(JsonMapperFactory factory) throws Exception {
         ArchieJacksonConfiguration configuration = ArchieJacksonConfiguration.createStandardsCompliant();
         configuration.setSerializeEmptyCollections(false);
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(configuration);
+        JsonMapper objectMapper = factory.create(configuration);
         DvText dvText = new DvText("");
-
-
         String actualJson = objectMapper.writeValueAsString(dvText);
         assertEquals(
-                        removeWhiteSpaces("{\n"
-                                + "  \"_type\" : \"DV_TEXT\",\n"
-                                + "  \"value\" : \"\"\n"
-                                + "}"), removeWhiteSpaces(actualJson));
+                removeWhiteSpaces("{\n"
+                        + "  \"_type\" : \"DV_TEXT\",\n"
+                        + "  \"value\" : \"\"\n"
+                        + "}"), removeWhiteSpaces(actualJson));
     }
 
-    @Test
-    public void emptyCollectionIsNotIncluded() throws JsonProcessingException {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void emptyCollectionIsNotIncluded(JsonMapperFactory factory) throws Exception {
         ArchieJacksonConfiguration configuration = ArchieJacksonConfiguration.createStandardsCompliant();
         configuration.setSerializeEmptyCollections(false);
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(configuration);
+        JsonMapper objectMapper = factory.create(configuration);
         DvText dvText = new DvText("");
         dvText.setMappings(new ArrayList<>());
-
-
         String actualJson = objectMapper.writeValueAsString(dvText);
         assertEquals(
                 removeWhiteSpaces("{\n"
@@ -114,24 +113,22 @@ public void emptyCollectionIsNotIncluded() throws JsonProcessingException {
                         + "}"), removeWhiteSpaces(actualJson));
     }
 
-    @Test
-    public void emptyCollectionInCollection() throws JsonProcessingException {
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void emptyCollectionInCollection(JsonMapperFactory factory) throws Exception {
         ArchieJacksonConfiguration configuration = ArchieJacksonConfiguration.createStandardsCompliant();
         configuration.setSerializeEmptyCollections(false);
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(configuration);
+        JsonMapper objectMapper = factory.create(configuration);
         Map<String, Map<String, String>> map = new LinkedHashMap<>();
         map.put("test", new LinkedHashMap<>());
-
-
         String actualJson = objectMapper.writeValueAsString(map);
-        assertEquals(
-                removeWhiteSpaces("{\"test\":{}}"),
-                removeWhiteSpaces(actualJson));
+        assertEquals(removeWhiteSpaces("{\"test\":{}}"), removeWhiteSpaces(actualJson));
     }
 
-    @Test
-    public void serializeDvDateTime() throws Exception {
-        ObjectMapper objectMapper = JacksonUtil.getObjectMapper(ArchieJacksonConfiguration.createStandardsCompliant());
+    @ParameterizedTest
+    @MethodSource("com.nedap.archie.json.JacksonTestMappers#mappers")
+    public void serializeDvDateTime(JsonMapperFactory factory) throws Exception {
+        JsonMapper objectMapper = factory.create(ArchieJacksonConfiguration.createStandardsCompliant());
         DvDateTime dateTime = new DvDateTime(LocalDateTime.of(2015, 1, 1, 12, 10, 12, 0));
         String dateTimeString = objectMapper.writeValueAsString(dateTime);
         assertTrue(dateTimeString.contains("\"2015-01-01T12:10:12\""));
@@ -160,7 +157,4 @@ public void serializeDvDateTime() throws Exception {
     String removeWhiteSpaces(String input) {
         return input.replaceAll("\\s+", "");
     }
-
-
-
 }
diff --git a/tools/src/test/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializerTest.java b/tools/src/test/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializerTest.java
index 7fdbfcfbb..443661f5f 100644
--- a/tools/src/test/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializerTest.java
+++ b/tools/src/test/java/com/nedap/archie/serializer/adl/ADLArchetypeSerializerTest.java
@@ -4,6 +4,7 @@
 import com.nedap.archie.adlparser.ADLParser;
 import com.nedap.archie.aom.Archetype;
 import com.nedap.archie.aom.rmoverlay.VisibilityType;
+import com.nedap.archie.serializer.adl.jackson3.ADLStringBuilder3;
 import com.nedap.archie.testutil.TestUtil;
 import org.junit.jupiter.api.Test;
 import org.openehr.referencemodels.BuiltinReferenceModels;
@@ -125,6 +126,39 @@ public void rmOverlay() throws Exception {
        assertEquals("at12", parsed.getRmOverlay().getRmVisibility().get("/subject").getAlias().getCodeString());
    }
 
+    @Test
+    public void serializeWithJackson3BuilderMatchesJackson2() throws Exception {
+        Archetype archetype = load("openEHR-EHR-COMPOSITION.report.v1.adls");
+        String j2Output = ADLArchetypeSerializer.serialize(archetype);
+        String j3Output = ADLArchetypeSerializer.serialize(archetype, null, null, ADLStringBuilder3::new);
+        assertEquals(j2Output, j3Output);
+    }
+
+    @Test
+    public void serializeWithJackson3BuilderMatchesJackson2TermConstraints() throws Exception {
+        Archetype archetype = load("openEHR-EHR-EVALUATION.term_constraint_variations.v0.0.1.adls");
+        String j2Output = ADLArchetypeSerializer.serialize(archetype);
+        String j3Output = ADLArchetypeSerializer.serialize(archetype, null, null, ADLStringBuilder3::new);
+        assertEquals(j2Output, j3Output);
+    }
+
+    @Test
+    public void serializeWithJackson3BuilderMatchesJackson2Device() throws Exception {
+        // device archetype has terms with description fields, covering ArchetypeTermOdinSerializer description branch
+        Archetype archetype = load("openEHR-EHR-CLUSTER.device.v1.adls");
+        String j2Output = ADLArchetypeSerializer.serialize(archetype);
+        String j3Output = ADLArchetypeSerializer.serialize(archetype, null, null, ADLStringBuilder3::new);
+        assertEquals(j2Output, j3Output);
+    }
+
+    @Test
+    public void serializeWithJackson3BuilderTemplate() throws Exception {
+        Archetype archetype = loadRoot("com/nedap/archie/archetypevalidator/openEHR-EHR-OBSERVATION.specialized_template_observation.v1.0.0.adls");
+        String j2Output = ADLArchetypeSerializer.serialize(archetype);
+        String j3Output = ADLArchetypeSerializer.serialize(archetype, null, null, ADLStringBuilder3::new);
+        assertEquals(j2Output, j3Output);
+    }
+
     private Archetype load(String resourceName) throws ADLParseException, IOException {
         return new ADLParser().parse(ADLArchetypeSerializerTest.class.getResourceAsStream(resourceName));
     }
diff --git a/utils/src/main/java/com/nedap/archie/json3/DateDeserializer.java b/utils/src/main/java/com/nedap/archie/json3/DateDeserializer.java
new file mode 100644
index 000000000..8023cb9c9
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/DateDeserializer.java
@@ -0,0 +1,21 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeParsers;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonParser;
+import tools.jackson.databind.DeserializationContext;
+import tools.jackson.databind.ValueDeserializer;
+
+import java.time.temporal.Temporal;
+
+public class DateDeserializer extends ValueDeserializer<Temporal> {
+
+    @Override
+    public Temporal deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+        String valueAsString = p.getValueAsString();
+        if(valueAsString == null || valueAsString.isEmpty()) {
+            return null;
+        }
+        return DateTimeParsers.parseDateValue(valueAsString);
+    }
+}
diff --git a/utils/src/main/java/com/nedap/archie/json3/DateTimeDeserializer.java b/utils/src/main/java/com/nedap/archie/json3/DateTimeDeserializer.java
new file mode 100644
index 000000000..4c61b9dc1
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/DateTimeDeserializer.java
@@ -0,0 +1,20 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeParsers;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonParser;
+import tools.jackson.databind.DeserializationContext;
+import tools.jackson.databind.ValueDeserializer;
+
+import java.time.temporal.TemporalAccessor;
+
+public class DateTimeDeserializer extends ValueDeserializer<TemporalAccessor> {
+    @Override
+    public TemporalAccessor deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+        String valueAsString = p.getValueAsString();
+        if (valueAsString == null || valueAsString.isEmpty()) {
+            return null;
+        }
+        return DateTimeParsers.parseDateTimeValue(valueAsString);
+    }
+}
diff --git a/utils/src/main/java/com/nedap/archie/json3/DateTimeSerializer.java b/utils/src/main/java/com/nedap/archie/json3/DateTimeSerializer.java
new file mode 100644
index 000000000..52e711824
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/DateTimeSerializer.java
@@ -0,0 +1,28 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeSerializerFormatters;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+import java.time.temporal.ChronoField;
+import java.time.temporal.TemporalAccessor;
+
+public class DateTimeSerializer extends ValueSerializer<TemporalAccessor> {
+
+    @Override
+    public void serialize(TemporalAccessor temporalAccessor, JsonGenerator jsonGenerator, SerializationContext ctxt) throws JacksonException {
+        if (temporalAccessor == null) {
+            jsonGenerator.writeString("");
+            return;
+        }
+        if (!temporalAccessor.isSupported(ChronoField.HOUR_OF_DAY) &&
+                !temporalAccessor.isSupported(ChronoField.MINUTE_OF_HOUR) &&
+                !temporalAccessor.isSupported(ChronoField.SECOND_OF_MINUTE)) {
+            jsonGenerator.writeString(DateTimeSerializerFormatters.ISO_8601_DATE.format(temporalAccessor));
+        } else {
+            jsonGenerator.writeString(DateTimeSerializerFormatters.ISO_8601_DATE_TIME.format(temporalAccessor));
+        }
+    }
+}
diff --git a/utils/src/main/java/com/nedap/archie/json3/DurationDeserializer.java b/utils/src/main/java/com/nedap/archie/json3/DurationDeserializer.java
new file mode 100644
index 000000000..a06177e47
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/DurationDeserializer.java
@@ -0,0 +1,20 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeParsers;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonParser;
+import tools.jackson.databind.DeserializationContext;
+import tools.jackson.databind.ValueDeserializer;
+
+import java.time.temporal.TemporalAmount;
+
+public class DurationDeserializer extends ValueDeserializer<TemporalAmount> {
+    @Override
+    public TemporalAmount deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+        String valueAsString = p.getValueAsString();
+        if (valueAsString == null || valueAsString.isEmpty()) {
+            return null;
+        }
+        return DateTimeParsers.parseDurationValue(valueAsString);
+    }
+}
diff --git a/utils/src/main/java/com/nedap/archie/json3/DurationSerializer.java b/utils/src/main/java/com/nedap/archie/json3/DurationSerializer.java
new file mode 100644
index 000000000..e87759504
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/DurationSerializer.java
@@ -0,0 +1,16 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeSerializerFormatters;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+import java.time.temporal.TemporalAmount;
+
+public class DurationSerializer extends ValueSerializer<TemporalAmount> {
+    @Override
+    public void serialize(TemporalAmount value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
+        gen.writeString(DateTimeSerializerFormatters.serializeDuration(value));
+    }
+}
diff --git a/utils/src/main/java/com/nedap/archie/json3/TimeDeserializer.java b/utils/src/main/java/com/nedap/archie/json3/TimeDeserializer.java
new file mode 100644
index 000000000..9531158b2
--- /dev/null
+++ b/utils/src/main/java/com/nedap/archie/json3/TimeDeserializer.java
@@ -0,0 +1,20 @@
+package com.nedap.archie.json3;
+
+import com.nedap.archie.datetime.DateTimeParsers;
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonParser;
+import tools.jackson.databind.DeserializationContext;
+import tools.jackson.databind.ValueDeserializer;
+
+import java.time.temporal.TemporalAccessor;
+
+public class TimeDeserializer extends ValueDeserializer<TemporalAccessor> {
+    @Override
+    public TemporalAccessor deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+        String valueAsString = p.getValueAsString();
+        if (valueAsString == null || valueAsString.isEmpty()) {
+            return null;
+        }
+        return DateTimeParsers.parseTimeValue(valueAsString);
+    }
+}