diff --git a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/EntityRelationWithDefaultsModelTest.java b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/EntityRelationWithDefaultsModelTest.java
index 567ddf13..d5358ab3 100644
--- a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/EntityRelationWithDefaultsModelTest.java
+++ b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/EntityRelationWithDefaultsModelTest.java
@@ -24,20 +24,26 @@
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelation.CollectorWithSingleOptionalDefaultRelation;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelation.CollectorWithSingleOptionalDefaultRelationDao;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelation.CollectorWithSingleOptionalDefaultRelationForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationextended.CollectorWithSingleOptionalDefaultRelationExtended;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationextended.CollectorWithSingleOptionalDefaultRelationExtendedDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationextended.CollectorWithSingleOptionalDefaultRelationExtendedForCreate;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelation.CollectorWithSingleRequiredDefaultRelation;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelation.CollectorWithSingleRequiredDefaultRelationDao;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelation.CollectorWithSingleRequiredDefaultRelationForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelationextended.CollectorWithSingleRequiredDefaultRelationExtended;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelationextended.CollectorWithSingleRequiredDefaultRelationExtendedDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsinglerequireddefaultrelationextended.CollectorWithSingleRequiredDefaultRelationExtendedForCreate;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.item.Item;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.item.ItemDao;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.item.ItemForCreate;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.guice.RelationWithDefaultsModelDaoModules;
 import hu.blackbelt.judo.runtime.core.jsl.fixture.JudoRuntimeExtension;
+import hu.blackbelt.judo.sdk.query.StringFilter;
 import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
 
 @Slf4j
 public class EntityRelationWithDefaultsModelTest {
@@ -52,32 +58,277 @@ public class EntityRelationWithDefaultsModelTest {
     CollectorWithSingleOptionalDefaultRelationDao collectorWithSingleOptionalDefaultRelationDao;
 
     @Test
-    @Disabled("https://blackbelt.atlassian.net/browse/JNG-6081")
     public void singleOptionalDefaultRelationTest() {
         // shortname
         CollectorWithSingleOptionalDefaultRelationDao collectorDao = collectorWithSingleOptionalDefaultRelationDao;
-        Item item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(1).build());
 
+        // The Default element is defined and no value added during the creation
+        Item item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(1).build());
         CollectorWithSingleOptionalDefaultRelation collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder().build());
 
         assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
+        itemDao.delete(item);
+
+        // Default element is undefined and no value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // No matching default element and no value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // Default element is undefined and value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(5).build())
+                .build()
+        );
+
+        Item itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemDao.delete(itemA1);
+
+        // Default element is not undefined and value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemDao.deleteAll(item, itemA1);
+
+        // No matching default element and value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
     }
 
     @Inject
     CollectorWithSingleRequiredDefaultRelationDao collectorWithSingleRequiredDefaultRelationDao;
 
     @Test
-    @Disabled("https://blackbelt.atlassian.net/browse/JNG-6081")
     public void singleRequiredDefaultRelationTest() {
         // shortname
         CollectorWithSingleRequiredDefaultRelationDao collectorDao = collectorWithSingleRequiredDefaultRelationDao;
+        // Default element is not undefined and no value added during the creation
+        Item item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        CollectorWithSingleRequiredDefaultRelation collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder().build());
+
+        assertEquals(item.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        // Default element is undefined and no value added during the creation
+        collectorDao.delete(collector);
+        itemDao
+                .delete(item);
+
+        // Error
+        IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        // No matching default element and no value added during the creation // Error
+        item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        itemDao
+                .delete(item);
+        // Default element is not undefined and value added during the creation
+        item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder()
+                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+
+        Item itemA1 = itemDao
+                .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        collectorDao.delete(collector);
+        itemDao
+                .deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+//        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder()
+//                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = itemDao
+//        .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemDao
+//        .delete(itemA1);
+
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+        // No matching default element and value added during the creation
+//        item = itemDao
+//        .create(ItemForCreate.builder().withName("A").withNumber(5).build());
+//        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder()
+//                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = itemDao
+//        .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemDao.delete(itemA1);
+    }
+
+    // Inherited default on entity
+    @Inject
+    CollectorWithSingleOptionalDefaultRelationExtendedDao collectorWithSingleOptionalDefaultRelationExtendedDao;
+
+    @Test
+    public void singleOptionalDefaultRelationInheritedTest() {
+        // shortname
+        CollectorWithSingleOptionalDefaultRelationExtendedDao collectorDao = collectorWithSingleOptionalDefaultRelationExtendedDao;
+
+        // Default element is not undefined and no value added during the creation
         Item item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        CollectorWithSingleOptionalDefaultRelationExtended collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder().build());
 
-        CollectorWithSingleRequiredDefaultRelation collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationForCreate.builder().build());
+        assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemDao.delete(item);
+
+        // Default element is undefined and no value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // No matching default element and no value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // Default element is undefined and value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(5).build())
+                .build()
+        );
+
+        Item itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemDao.delete(itemA1);
+
+        // Default element is not undefined and value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemDao.deleteAll(item, itemA1);
+
+        // No matching default element and value added during the creation
+        item = itemDao.create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationExtendedForCreate.builder()
+                .withOptItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+    }
+
+    @Inject
+    CollectorWithSingleRequiredDefaultRelationExtendedDao collectorWithSingleRequiredDefaultRelationExtendedDao;
+
+    @Test
+    public void singleRequiredDefaultRelationInheritedTest() {
+        // shortname
+        CollectorWithSingleRequiredDefaultRelationExtendedDao collectorDao = collectorWithSingleRequiredDefaultRelationExtendedDao;
+
+        // Default element is not undefined and no value added during the creation
+        Item item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        CollectorWithSingleRequiredDefaultRelationExtended collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder().build());
 
         assertEquals(item.identifier(), collectorDao.queryReqItem(collector).identifier());
 
+        // Default element is undefined and no value added during the creation
+        collectorDao.delete(collector);
+        itemDao
+                .delete(item);
+
+        // Error
+        IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        // No matching default element and no value added during the creation // Error
+        item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(5).build());
+        thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        itemDao
+                .delete(item);
+        // Default element is not undefined and value added during the creation
+        item = itemDao
+                .create(ItemForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder()
+                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+
+        Item itemA1 = itemDao
+                .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        collectorDao.delete(collector);
+        itemDao
+                .deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+//        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder()
+//                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = itemDao
+//        .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemDao
+//        .delete(itemA1);
+
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+        // No matching default element and value added during the creation
+//        item = itemDao
+//        .create(ItemForCreate.builder().withName("A").withNumber(5).build());
+//        collector = collectorDao.create(CollectorWithSingleRequiredDefaultRelationExtendedForCreate.builder()
+//                .withReqItem(Item.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = itemDao
+//        .query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemDao.delete(itemA1);
+
     }
 
 }
diff --git a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/TransferRelationWithDefaultsModelTest.java b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/TransferRelationWithDefaultsModelTest.java
index fe697be2..d91f6eff 100644
--- a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/TransferRelationWithDefaultsModelTest.java
+++ b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/java/hu/blackbelt/judo/runtime/core/jsl/entity/TransferRelationWithDefaultsModelTest.java
@@ -21,6 +21,18 @@
  */
 
 import com.google.inject.Inject;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaldefaulttransfer.CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransfer;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaldefaulttransfer.CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaldefaulttransfer.CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaltransfer.CollectorWithSingleOptionalDefaultRelationOptionalTransfer;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaltransfer.CollectorWithSingleOptionalDefaultRelationOptionalTransferDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationoptionaltransfer.CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequireddefaulttransfer.CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransfer;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequireddefaulttransfer.CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequireddefaulttransfer.CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequiredtransfer.CollectorWithSingleOptionalDefaultRelationRequiredTransfer;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequiredtransfer.CollectorWithSingleOptionalDefaultRelationRequiredTransferDao;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionaldefaultrelationrequiredtransfer.CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionalrelationoptionaldefaulttransfer.CollectorWithSingleOptionalRelationOptionalDefaultTransfer;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionalrelationoptionaldefaulttransfer.CollectorWithSingleOptionalRelationOptionalDefaultTransferDao;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.collectorwithsingleoptionalrelationoptionaldefaulttransfer.CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate;
@@ -47,9 +59,11 @@
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.itemtransfer.ItemTransfer;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.itemtransfer.ItemTransferDao;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.itemtransfer.ItemTransferForCreate;
+import hu.blackbelt.judo.psm.generator.sdk.core.test.api.relationwithdefaultsmodel.relationwithdefaultsmodel.itemtransfer.ItemTransferQueryCustomizer;
 import hu.blackbelt.judo.psm.generator.sdk.core.test.guice.RelationWithDefaultsModelDaoModules;
 import hu.blackbelt.judo.runtime.core.exception.ValidationException;
 import hu.blackbelt.judo.runtime.core.jsl.fixture.JudoRuntimeExtension;
+import hu.blackbelt.judo.sdk.query.NumberFilter;
 import hu.blackbelt.judo.sdk.query.StringFilter;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.Disabled;
@@ -75,16 +89,16 @@ public class TransferRelationWithDefaultsModelTest {
 
     // Variations
     /*
-    op - op
-    op - op default
-    op - req
-    op - req default
+    opt - opt
+    opt - opt default
+    opt - req
+    opt - req default
      */
 
     @Inject
     CollectorWithSingleOptionalRelationOptionalTransferDao collectorWithSingleOptionalRelationOptionalTransferDao;
 
-    // op - op
+    // opt - opt
 
     @Test
     public void singleOptionalRelationOptionalTransferTest() {
@@ -93,7 +107,7 @@ public void singleOptionalRelationOptionalTransferTest() {
 
         CollectorWithSingleOptionalRelationOptionalTransfer collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalTransferForCreate.builder().build());
 
-        assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
 
     }
 
@@ -101,7 +115,7 @@ public void singleOptionalRelationOptionalTransferTest() {
     CollectorWithSingleOptionalRelationOptionalDefaultTransferDao collectorWithSingleOptionalDefaultRelationTransferDao;
 
 
-    // op - op default
+    // opt - opt default
 
     @Test
     public void singleOptionalRelationOptionalDefaultTransferTest() {
@@ -112,58 +126,58 @@ public void singleOptionalRelationOptionalDefaultTransferTest() {
         ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
         CollectorWithSingleOptionalRelationOptionalDefaultTransfer collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder().build());
 
-        assertEquals(item.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         // Default element is undefined and no value added during the creation
         itemTransferDao.delete(item);
         collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder().build());
 
-        assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
 
         // No matching default element and no value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
         collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder().build());
 
-        assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
 
         itemTransferDao.delete(item);
 
         // Default element is not undefined and value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
         collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         ItemTransfer itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         itemTransferDao.deleteAll(item, itemA1);
 
         // Default element is undefined and value added during the creation
         collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         itemTransferDao.delete(itemA1);
 
         // No matching default element and value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
         collector = collectorDao.create(CollectorWithSingleOptionalRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
     }
 
     @Inject
     CollectorWithSingleOptionalRelationRequiredTransferDao singleOptionalRelationRequiredTransferDao;
 
-    // op - req
+    // opt - req
 
     @Test
     public void singleRequiredRelationRequiredTransferTest() {
@@ -182,7 +196,7 @@ public void singleRequiredRelationRequiredTransferTest() {
     @Inject
     CollectorWithSingleOptionalRelationRequiredDefaultTransferDao collectorWithSingleOptionalRelationRequiredDefaultTransferDao;
 
-    // op - req default
+    // opt - req default
 
     @Test
     public void singleOptionalRelationRequiredDefaultTransferTest() {
@@ -250,8 +264,8 @@ public void singleOptionalRelationRequiredDefaultTransferTest() {
 
     // Variations
     /*
-    req - op
-    req - op default
+    req - opt
+    req - opt default
     req - req
     req - req default
      */
@@ -262,7 +276,7 @@ public void singleOptionalRelationRequiredDefaultTransferTest() {
     @Inject
     CollectorWithSingleRequiredRelationDao collectorWithSingleRequiredRelationDao;
 
-    // req - op
+    // req - opt
 
     // TODO: Creation should throw an error if the required entity relation remains empty in the transfer optional.
     @Test
@@ -274,7 +288,7 @@ public void singleRequiredRelationOptionalTransfer() {
         // Should throw error
         CollectorWithSingleRequiredRelationOptionalTransfer collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalTransferForCreate.builder().build());
 
-        assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
 
         // Empty query result for required reference: reqItem
         collectorWithSingleRequiredRelationDao.queryReqItem((UUID) collector.identifier().getIdentifier());
@@ -285,7 +299,7 @@ public void singleRequiredRelationOptionalTransfer() {
     @Inject
     CollectorWithSingleRequiredRelationOptionalDefaultTransferDao collectorWithSingleRequiredRelationOptionalDefaultTransferDao;
 
-    // req - op default
+    // req - opt default
 
     @Test
     public void singleRequiredRelationOptionalDefaultTransferTest() {
@@ -296,24 +310,26 @@ public void singleRequiredRelationOptionalDefaultTransferTest() {
         ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
         CollectorWithSingleRequiredRelationOptionalDefaultTransfer collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder().build());
 
-        assertEquals(item.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         // Default element is undefined and no value added during the creation
         collectorDao.delete(collector);
         itemTransferDao.delete(item);
         // TODO Should throw error
+        // TODO JNG-6083
         collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder().build());
 
-        //assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        //assertTrue(collectorDao.queryOptItem(collector).isEmpty());
         // Empty query result for required reference: reqItem
         //collectorWithSingleRequiredRelationDao.queryReqItem((UUID) collector.identifier().getIdentifier());
 
         // No matching default element and no value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
         // TODO Should throw error
+        // TODO JNG-6083
         collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder().build());
 
-        //assertTrue(collectorDao.queryOpItem(collector).isEmpty());
+        //assertTrue(collectorDao.queryOptItem(collector).isEmpty());
         //collectorWithSingleRequiredRelationDao.queryReqItem((UUID) collector.identifier().getIdentifier());
 
         itemTransferDao.delete(item);
@@ -321,22 +337,22 @@ public void singleRequiredRelationOptionalDefaultTransferTest() {
         // Default element is not undefined and value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
         collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         ItemTransfer itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         collectorDao.delete(collector);
         itemTransferDao.deleteAll(item, itemA1);
 
         // Default element is undefined and value added during the creation
         collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
         collectorDao.delete(collector);
         itemTransferDao.delete(itemA1);
@@ -344,11 +360,11 @@ public void singleRequiredRelationOptionalDefaultTransferTest() {
         // No matching default element and value added during the creation
         item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
         collector = collectorDao.create(CollectorWithSingleRequiredRelationOptionalDefaultTransferForCreate.builder()
-                .withOpItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
                 .build()
         );
         itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
-        assertEquals(itemA1.identifier(), collectorDao.queryOpItem(collector).orElseThrow().identifier());
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
 
     }
 
@@ -441,4 +457,297 @@ public void SingleOptionalRelationRequiredDefaultTransferTest() {
 
     }
 
+    @Inject
+    CollectorWithSingleOptionalDefaultRelationOptionalTransferDao collectorWithSingleOptionalDefaultRelationOptionalTransferDao;
+
+    // Variations
+    /*
+    opt default - opt
+    opt default - opt default
+    opt default - req
+    opt default - req default
+     */
+
+    // opt default - opt
+
+    @Test
+    public void SingleOptionalDefaultRelationOptionalTransferTest() {
+        CollectorWithSingleOptionalDefaultRelationOptionalTransferDao collectorDao = collectorWithSingleOptionalDefaultRelationOptionalTransferDao;
+
+        // Default element is not undefined and no value added during the creation
+        ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
+        CollectorWithSingleOptionalDefaultRelationOptionalTransfer collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder().build());
+
+        assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        // Default element is undefined and no value added during the creation
+        itemTransferDao.delete(item);
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // No matching default element and no value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        itemTransferDao.delete(item);
+
+        // Default element is not undefined and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        ItemTransfer itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemTransferDao.deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemTransferDao.delete(itemA1);
+
+        // No matching default element and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+    }
+
+    @Inject
+    CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferDao collectorWithSingleOptionalDefaultRelationOptionalDefaultTransferDao;
+
+    // opt default - opt default
+
+    @Test
+    public void SingleOptionalDefaultRelationOptionalDefaultTransferTest() {
+        CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferDao collectorDao = collectorWithSingleOptionalDefaultRelationOptionalDefaultTransferDao;
+
+        // Default element is not undefined and no value added during the creation
+        ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A1").withNumber(1).build());
+        CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransfer collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder().build());
+
+        assertEquals(item.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        // Default element is undefined and no value added during the creation
+        itemTransferDao.delete(item);
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder().build());
+
+        assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        // No matching default element and no value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder().build());
+
+        //TODO should be null instead of entity default
+        // TODO JNG-6106
+        //assertTrue(collectorDao.queryOptItem(collector).isEmpty());
+
+        itemTransferDao.delete(item);
+
+        // Default element is not undefined and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A1").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        ItemTransfer itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).filterByNumber(NumberFilter.equalTo(11)).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemTransferDao.deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+        itemTransferDao.delete(itemA1);
+
+        // No matching default element and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransferForCreate.builder()
+                .withOptItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+        itemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryOptItem(collector).orElseThrow().identifier());
+
+    }
+
+    @Inject
+    CollectorWithSingleOptionalDefaultRelationRequiredTransferDao collectorWithSingleOptionalDefaultRelationRequiredTransferDao;
+
+    // opt default - req
+
+    @Test
+    @Disabled("JNG-6103")
+    // TODO should refactor after default rework
+    public void SingleOptionalDefaultRelationRequiredTransferTest() {
+        // shortname
+        CollectorWithSingleOptionalDefaultRelationRequiredTransferDao collectorDao = collectorWithSingleOptionalDefaultRelationRequiredTransferDao;
+
+        // Default element is not undefined and no value added during the creation
+        ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
+
+        // TODO should use the entity default here, instead of validation error
+        // TODO JNG-6104
+        CollectorWithSingleOptionalDefaultRelationRequiredTransfer collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder().build());
+
+        assertEquals(item.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        // Default element is undefined and no value added during the creation
+        collectorDao.delete(collector);
+        itemTransferDao.delete(item);
+
+        // Error
+        IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        // No matching default element and no value added during the creation // Error
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+        thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        itemTransferDao.delete(item);
+        // Default element is not undefined and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder()
+                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+
+        ItemTransferQueryCustomizer filterItemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).filterByNumber(NumberFilter.equalTo(11));
+        ItemTransfer itemA1 = filterItemA1.selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        collectorDao.delete(collector);
+        itemTransferDao.deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+//        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder()
+//                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = filterItemA1.selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemTransferDao.delete(itemA1);
+
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+        // No matching default element and value added during the creation
+//        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+//        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredTransferForCreate.builder()
+//                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = filterItemA1.selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemTransferDao.delete(itemA1);
+
+    }
+
+    @Inject
+    CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferDao collectorWithSingleOptionalDefaultRelationRequiredDefaultTransferDao;
+
+    // opt default - req
+
+    @Test
+    public void SingleOptionalDefaultRelationRequiredDefaultTransferTest() {
+        // shortname
+        CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferDao collectorDao = collectorWithSingleOptionalDefaultRelationRequiredDefaultTransferDao;
+
+        // Default element is not undefined and no value added during the creation
+        ItemTransfer item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A1").withNumber(1).build());
+
+        // TODO should use the entity default here, instead of validation error
+        // TODO JNG-6104
+        CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransfer collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder().build());
+
+        assertEquals(item.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        // Default element is undefined and no value added during the creation
+        collectorDao.delete(collector);
+        itemTransferDao.delete(item);
+
+        // Error
+        IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        // No matching default element and no value added during the creation // Error
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+        thrown = assertThrows(IllegalStateException.class, () -> collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder().build()));
+        assertTrue(thrown.getMessage().contains("Default reference value is undefined"));
+
+        itemTransferDao.delete(item);
+        // Default element is not undefined and value added during the creation
+        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A1").withNumber(1).build());
+        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder()
+                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+                .build()
+        );
+
+        ItemTransferQueryCustomizer filterItemA1 = itemTransferDao.query().filterByName(StringFilter.equalTo("A1")).filterByNumber(NumberFilter.equalTo(11));
+        ItemTransfer itemA1 = filterItemA1.selectOne().orElseThrow();
+        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+
+        collectorDao.delete(collector);
+        itemTransferDao.deleteAll(item, itemA1);
+
+        // Default element is undefined and value added during the creation
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+//        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder()
+//                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = filterItemA1.selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemTransferDao.delete(itemA1);
+
+        // TODO Default is undefined, IllegalStateException Default reference value is undefined
+        // TODO JNG-4194
+        // No matching default element and value added during the creation
+//        item = itemTransferDao.create(ItemTransferForCreate.builder().withName("A").withNumber(5).build());
+//        collector = collectorDao.create(CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransferForCreate.builder()
+//                .withReqItem(ItemTransfer.builder().withName("A1").withNumber(11).build())
+//                .build()
+//        );
+//
+//        itemA1 = filterItemA1.selectOne().orElseThrow();
+//        assertEquals(itemA1.identifier(), collectorDao.queryReqItem(collector).identifier());
+//        itemTransferDao.delete(itemA1);
+
+    }
+
+    // TODO Should add after or during the default rework
+    // TODO JNG-6105
+    // Variations
+    /*
+    req default - opt
+    req default - opt default
+    req default - req
+    req default - req default
+     */
+
+
 }
diff --git a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/resources/RelationWithDefaultsModel.jsl b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/resources/RelationWithDefaultsModel.jsl
index ee3a0942..7cfb985d 100644
--- a/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/resources/RelationWithDefaultsModel.jsl
+++ b/judo-runtime-core-jsl-itest/models/RelationWithDefaultsModel/src/test/resources/RelationWithDefaultsModel.jsl
@@ -21,25 +21,25 @@ transfer ItemTransfer(Item i) {
 // optional entity without default
 
 entity CollectorWithSingleOptionalRelation {
-    relation Item opItem;
+    relation Item optItem;
 }
 
 // related transfers (optional, optional with default, required, required with default)
 
 transfer CollectorWithSingleOptionalRelationOptionalTransfer(CollectorWithSingleOptionalRelation c) {
-    relation ItemTransfer opItem <= c.opItem create:true;
+    relation ItemTransfer optItem <= c.optItem create:true;
 }
 
 transfer CollectorWithSingleOptionalRelationOptionalDefaultTransfer(CollectorWithSingleOptionalRelation c) {
-    relation ItemTransfer opItem <= c.opItem create:true default: Item.all().filter(i | i.number < 4).any();
+    relation ItemTransfer optItem <= c.optItem create:true default: Item.all().filter(i | i.number < 4).any();
 }
 
 transfer CollectorWithSingleOptionalRelationRequiredTransfer(CollectorWithSingleOptionalRelation c) {
-    relation ItemTransfer reqItem <= c.opItem required;
+    relation ItemTransfer reqItem <= c.optItem required;
 }
 
 transfer CollectorWithSingleOptionalRelationRequiredDefaultTransfer(CollectorWithSingleOptionalRelation c) {
-    relation ItemTransfer reqItem <= c.opItem create:true default: Item.all().filter(i | i.number < 4).any() required;
+    relation ItemTransfer reqItem <= c.optItem create:true default: Item.all().filter(i | i.number < 4).any() required;
 }
 
 // required entity without default
@@ -51,11 +51,11 @@ entity CollectorWithSingleRequiredRelation {
 // related transfers (optional, optional with default, required, required with default)
 
 transfer CollectorWithSingleRequiredRelationOptionalTransfer(CollectorWithSingleRequiredRelation c) {
-    relation ItemTransfer opItem <= c.reqItem create:true;
+    relation ItemTransfer optItem <= c.reqItem create:true;
 }
 
 transfer CollectorWithSingleRequiredRelationOptionalDefaultTransfer(CollectorWithSingleRequiredRelation c) {
-    relation ItemTransfer opItem <= c.reqItem create:true default: Item.all().filter(i | i.number < 4).any();
+    relation ItemTransfer optItem <= c.reqItem create:true default: Item.all().filter(i | i.number < 4).any();
 }
 
 transfer CollectorWithSingleRequiredRelationRequiredTransfer(CollectorWithSingleRequiredRelation c) {
@@ -73,8 +73,34 @@ entity CollectorWithSingleOptionalDefaultRelation {
     relation Item optItem default: Item.all().filter(i | i.number < 4).any();
 }
 
-// optional entity with default
+// inherited relation default
+entity CollectorWithSingleOptionalDefaultRelationExtended extends CollectorWithSingleOptionalDefaultRelation {
+}
+
+// transfer
+
+transfer CollectorWithSingleOptionalDefaultRelationOptionalTransfer(CollectorWithSingleOptionalDefaultRelation c) {
+    relation ItemTransfer optItem <= c.optItem create:true;
+}
+
+transfer CollectorWithSingleOptionalDefaultRelationOptionalDefaultTransfer(CollectorWithSingleOptionalDefaultRelation c) {
+    relation ItemTransfer optItem <= c.optItem create:true default: Item.all().filter(i | i.name == "A1").any();
+}
 
+transfer CollectorWithSingleOptionalDefaultRelationRequiredTransfer(CollectorWithSingleOptionalDefaultRelation c) {
+    relation ItemTransfer reqItem <= c.optItem create:true required;
+}
+
+transfer CollectorWithSingleOptionalDefaultRelationRequiredDefaultTransfer(CollectorWithSingleOptionalDefaultRelation c) {
+    relation ItemTransfer reqItem <= c.optItem create:true default: Item.all().filter(i | i.name == "A1").any() required;
+}
+
+// required entity with default
 entity CollectorWithSingleRequiredDefaultRelation {
     relation Item reqItem default: Item.all().filter(i | i.number < 4).any() required;
-}
\ No newline at end of file
+}
+
+// inherited relation default
+entity CollectorWithSingleRequiredDefaultRelationExtended extends CollectorWithSingleRequiredDefaultRelation {
+}
+
diff --git a/pom.xml b/pom.xml
index 374dc726..c77f1114 100644
--- a/pom.xml
+++ b/pom.xml
@@ -43,7 +43,7 @@
             javax.resource;version="[1.6,2)"
         </osgi-transaction-import>
 
-        <judo-tatami-jsl-version>1.1.4.20250108_125648_5669c1a9_develop</judo-tatami-jsl-version>
+        <judo-tatami-jsl-version>1.1.4.20250110_103837_8a62d874_feature_JNG_6081_Default_relation_elements_arent_transform_in_Entity</judo-tatami-jsl-version>
         <judo-runtime-core-version>1.0.6.20250108_115741_c8a3626a_develop</judo-runtime-core-version>
         <judo-psm-generator-sdk-core-version>1.0.0.20241216_144906_8009d231_develop</judo-psm-generator-sdk-core-version>