Below is the structure I would ideally have for my json files and concrete classes.
I cant get it to work though, and the alternatives would be less elegant.

It fails at test 3, with this error:

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: 

Cannot construct instance of `com.org.DeserializationTest$InterfaceB` 
(no Creators, like default constructor, exist): 
abstract types either need to be mapped to concrete types, 
have custom deserializer, or contain additional type information

 at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` 
disabled); line: 3, column: 5]

Any help would be appreciated!

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import static com.fasterxml.jackson.annotation.JsonTypeInfo.As.EXISTING_PROPERTY;

public class DeserializationTest {
    final ObjectMapper om = new ObjectMapper();

    @Test
    void one() throws JsonProcessingException {
        Assertions.assertInstanceOf(ConcreteClass2.class,
                                    om.readValue("""
                                                         {
                                                             "typeA": "B",
                                                             "typeB": "B2"
                                                         }""", InterfaceB.class));
    }

    @Test
    void two() throws JsonProcessingException {
        Assertions.assertInstanceOf(ConcreteClass1.class,
                                    om.readValue("""
                                                         {
                                                             "typeA": "A1"
                                                         }""", InterfaceA.class));
    }

    @Test
    void three() throws JsonProcessingException {
        Assertions.assertInstanceOf(ConcreteClass2.class,
                                    om.readValue("""
                                                         {
                                                             "typeA": "B",
                                                             "typeB": "B2"
                                                         }""", InterfaceA.class));
    }


    @JsonTypeInfo(
            use = JsonTypeInfo.Id.NAME, include = EXISTING_PROPERTY,
            property = "typeA"
    )
    @JsonSubTypes({
            @JsonSubTypes.Type(value = ConcreteClass1.class, name = "A1"),
            @JsonSubTypes.Type(value = InterfaceB.class, name = "B")
    })
    public interface InterfaceA {
        String getTypeA();

        String getTypeB();
    }

    @JsonTypeInfo(
            use = JsonTypeInfo.Id.NAME, include = EXISTING_PROPERTY,
            property = "typeB"
    )
    @JsonSubTypes({
            @JsonSubTypes.Type(value = ConcreteClass2.class, name = "B2"),
            @JsonSubTypes.Type(value = ConcreteClass3.class, name = "B3")
    })
    public interface InterfaceB extends InterfaceA {
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class ConcreteClass1 implements InterfaceA {
        @Override
        public String getTypeA() {
            return "A1";
        }

        @Override
        public String getTypeB() {
            return null;
        }
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class ConcreteClass2 implements InterfaceB {
        @Override
        public String getTypeA() {
            return "B";
        }

        @Override
        public String getTypeB() {
            return "B2";
        }
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class ConcreteClass3 implements InterfaceB {
        @Override
        public String getTypeA() {
            return "B";
        }

        @Override
        public String getTypeB() {
            return "B3";
        }
    }
}

ChatGPT and current answers like this didnt help: Jackson Polymorphism: Nested Subtypes